From b8f9b0b007a4ac47d54962a51194662e47ea9af0 Mon Sep 17 00:00:00 2001 From: "randomizedcoder dave.seddon.ca@gmail.com" Date: Wed, 9 Sep 2026 17:44:25 -0700 Subject: [PATCH 1/4] =?UTF-8?q?feat(ipfeed):=20fold=20ipfeed-collector=20i?= =?UTF-8?q?nto=20xtcp2=20+=20IP=E2=86=92ASN=20enrichment?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Move the ipfeed-collector daemon from the internal repo into this single module and wire its IP-range feeds into xtcp2's per-socket enrichment. Phase 0 — move (no behavior change): - binary -> cmd/ipfeed-collector; guts -> internal/ipfeed/* - drop the tool's go.mod; merge deps into the root module - replace the self-contained flake with the repo's Nix machinery (binaries.nix, cli-help-smoke, oci image, checks/tests) Phase 1 — pkg/ipasn consumer + asnmap producer: - internal/ipfeed/asnmap: curated networkOwner/provider -> representative ASN table; Annotate() sets model.Record.ASN before WriteParquet - pkg/ipasn: gaissmai/bart LPM trie loaded from the collector artifact, atomic hot-swap, alloc/lock-free Lookup; table-driven + race + bench tests Phase 2 — hot-path wiring: - flat-record proto: new inet_diag_msg_socket_dest_network_owner (1018), threaded through the s3parquet ParquetRow/schema and ClickHouse DDL - config proto: enrich_asn_enable / asn_db_path / asn_refresh_interval - pkg/xtcp: initAsnEnricher loads the artifact and (optionally) refreshes on an interval; applyEnrichment fills dest_asn (1011) + dest_network_owner (1018) from the destination IP, no-op when disabled or index nil Design doc: docs/ipfeed-asn-enrichment.md (lookup-structure pros/cons + in-proc bart recommendation; representative-ASN caveat; BGP RIB deferred). Co-Authored-By: Claude Opus 4.8 --- buf.lock | 4 +- .../format_schemas/xtcp_flat_record.proto | 6 + .../initdb.d/sql/xtcp_xtcp_flat_records.sql | 1 + .../sql/xtcp_xtcp_flat_records_kafka.sql | 1 + cmd/ipfeed-collector/DESIGN.md | 357 ++++ cmd/ipfeed-collector/README.md | 187 ++ cmd/ipfeed-collector/main.go | 546 ++++++ cmd/ipfeed-collector/main_test.go | 342 ++++ .../sources/apple-privaterelay.yaml | 16 + cmd/ipfeed-collector/sources/applebot.yaml | 11 + cmd/ipfeed-collector/sources/atlassian.yaml | 10 + .../sources/aws-geo-feed.yaml | 14 + .../sources/aws-ip-ranges.yaml | 10 + .../sources/azure-service-tags.yaml | 11 + .../sources/cloudflare-v4.yaml | 11 + .../sources/cloudflare-v6.yaml | 11 + .../sources/digitalocean.yaml | 14 + cmd/ipfeed-collector/sources/fastly.yaml | 10 + cmd/ipfeed-collector/sources/gcp-cloud.yaml | 10 + cmd/ipfeed-collector/sources/gcp-goog.yaml | 10 + cmd/ipfeed-collector/sources/github-meta.yaml | 10 + .../sources/google-common-crawlers.yaml | 11 + .../sources/google-special-crawlers.yaml | 11 + .../google-user-triggered-fetchers.yaml | 11 + .../sources/m365-worldwide.yaml | 11 + cmd/ipfeed-collector/sources/oci.yaml | 10 + cmd/ipfeed-collector/sources/salesforce.yaml | 11 + docs/ipfeed-asn-enrichment.md | 117 ++ gen/cpp/xtcp_config/v1/xtcp_config.pb.cc | 590 ++++--- gen/cpp/xtcp_config/v1/xtcp_config.pb.h | 410 ++++- .../v1/xtcp_flat_record.pb.cc | 1549 +++++++++-------- .../xtcp_flat_record/v1/xtcp_flat_record.pb.h | 559 +++--- gen/dart/xtcp_config/v1/xtcp_config.pb.dart | 49 + .../xtcp_config/v1/xtcp_config.pbjson.dart | 27 +- .../v1/xtcp_flat_record.pb.dart | 593 ++++--- .../v1/xtcp_flat_record.pbjson.dart | 183 +- gen/go/xtcp_config/xtcp_config.pb.go | 87 +- gen/go/xtcp_config/xtcp_config_vtproto.pb.go | 132 ++ .../xtcp_flat_record/xtcp_flat_record.pb.go | 17 +- .../xtcp_flat_record_vtproto.pb.go | 45 + .../xtcp_config/v1/xtcp_config.swagger.json | 12 + gen/python/xtcp_config/v1/xtcp_config_pb2.py | 18 +- gen/python/xtcp_config/v1/xtcp_config_pb2.pyi | 10 +- .../v1/xtcp_flat_record_pb2.py | 28 +- .../v1/xtcp_flat_record_pb2.pyi | 6 +- go.mod | 51 +- go.sum | 133 +- internal/ipfeed/asnmap/asnmap.go | 64 + internal/ipfeed/asnmap/asnmap_test.go | 57 + internal/ipfeed/combine/combine.go | 85 + internal/ipfeed/combine/combine_bench_test.go | 43 + internal/ipfeed/combine/combine_test.go | 137 ++ internal/ipfeed/config/source.go | 145 ++ internal/ipfeed/config/source_test.go | 94 + internal/ipfeed/fetch/discover.go | 33 + internal/ipfeed/fetch/discover_test.go | 64 + internal/ipfeed/fetch/fetch.go | 209 +++ internal/ipfeed/fetch/fetch_race_test.go | 50 + internal/ipfeed/fetch/fetch_test.go | 128 ++ internal/ipfeed/health/health.go | 91 + internal/ipfeed/health/health_race_test.go | 47 + internal/ipfeed/health/health_test.go | 53 + internal/ipfeed/model/record.go | 37 + internal/ipfeed/output/parquet.go | 47 + internal/ipfeed/output/parquet_bench_test.go | 55 + internal/ipfeed/output/parquet_test.go | 74 + internal/ipfeed/parse/csv.go | 72 + internal/ipfeed/parse/json_atlassian.go | 43 + internal/ipfeed/parse/json_aws.go | 58 + internal/ipfeed/parse/json_azure.go | 50 + internal/ipfeed/parse/json_fastly.go | 33 + internal/ipfeed/parse/json_github.go | 51 + internal/ipfeed/parse/json_m365.go | 39 + internal/ipfeed/parse/json_oci.go | 45 + internal/ipfeed/parse/json_prefixes.go | 59 + internal/ipfeed/parse/json_salesforce.go | 54 + internal/ipfeed/parse/opts.go | 37 + internal/ipfeed/parse/parse_bench_test.go | 93 + internal/ipfeed/parse/parse_test.go | 212 +++ internal/ipfeed/parse/registry.go | 95 + internal/ipfeed/parse/text_cidr.go | 40 + internal/ipfeed/s3/uploader.go | 114 ++ internal/ipfeed/s3/uploader_test.go | 74 + internal/ipfeed/summary/summary.go | 109 ++ internal/ipfeed/telemetry/otel.go | 131 ++ nix/binaries.nix | 1 + nix/checks/cli-help-smoke.nix | 1 + nix/containers/default.nix | 32 + nix/default.nix | 2 + nix/lib/mkOciImage.nix | 4 + nix/versions.nix | 2 +- pkg/ipasn/ipasn.go | 126 ++ pkg/ipasn/ipasn_test.go | 167 ++ pkg/xtcp/destinations_s3parquet.go | 35 +- pkg/xtcp/destinations_s3parquet_schema.go | 35 +- pkg/xtcp/enrich.go | 82 + pkg/xtcp/xtcp.go | 7 + proto/xtcp_config/v1/xtcp_config.proto | 16 + .../v1/xtcp_flat_record.proto | 6 + 99 files changed, 7844 insertions(+), 1867 deletions(-) create mode 100644 cmd/ipfeed-collector/DESIGN.md create mode 100644 cmd/ipfeed-collector/README.md create mode 100644 cmd/ipfeed-collector/main.go create mode 100644 cmd/ipfeed-collector/main_test.go create mode 100644 cmd/ipfeed-collector/sources/apple-privaterelay.yaml create mode 100644 cmd/ipfeed-collector/sources/applebot.yaml create mode 100644 cmd/ipfeed-collector/sources/atlassian.yaml create mode 100644 cmd/ipfeed-collector/sources/aws-geo-feed.yaml create mode 100644 cmd/ipfeed-collector/sources/aws-ip-ranges.yaml create mode 100644 cmd/ipfeed-collector/sources/azure-service-tags.yaml create mode 100644 cmd/ipfeed-collector/sources/cloudflare-v4.yaml create mode 100644 cmd/ipfeed-collector/sources/cloudflare-v6.yaml create mode 100644 cmd/ipfeed-collector/sources/digitalocean.yaml create mode 100644 cmd/ipfeed-collector/sources/fastly.yaml create mode 100644 cmd/ipfeed-collector/sources/gcp-cloud.yaml create mode 100644 cmd/ipfeed-collector/sources/gcp-goog.yaml create mode 100644 cmd/ipfeed-collector/sources/github-meta.yaml create mode 100644 cmd/ipfeed-collector/sources/google-common-crawlers.yaml create mode 100644 cmd/ipfeed-collector/sources/google-special-crawlers.yaml create mode 100644 cmd/ipfeed-collector/sources/google-user-triggered-fetchers.yaml create mode 100644 cmd/ipfeed-collector/sources/m365-worldwide.yaml create mode 100644 cmd/ipfeed-collector/sources/oci.yaml create mode 100644 cmd/ipfeed-collector/sources/salesforce.yaml create mode 100644 docs/ipfeed-asn-enrichment.md create mode 100644 internal/ipfeed/asnmap/asnmap.go create mode 100644 internal/ipfeed/asnmap/asnmap_test.go create mode 100644 internal/ipfeed/combine/combine.go create mode 100644 internal/ipfeed/combine/combine_bench_test.go create mode 100644 internal/ipfeed/combine/combine_test.go create mode 100644 internal/ipfeed/config/source.go create mode 100644 internal/ipfeed/config/source_test.go create mode 100644 internal/ipfeed/fetch/discover.go create mode 100644 internal/ipfeed/fetch/discover_test.go create mode 100644 internal/ipfeed/fetch/fetch.go create mode 100644 internal/ipfeed/fetch/fetch_race_test.go create mode 100644 internal/ipfeed/fetch/fetch_test.go create mode 100644 internal/ipfeed/health/health.go create mode 100644 internal/ipfeed/health/health_race_test.go create mode 100644 internal/ipfeed/health/health_test.go create mode 100644 internal/ipfeed/model/record.go create mode 100644 internal/ipfeed/output/parquet.go create mode 100644 internal/ipfeed/output/parquet_bench_test.go create mode 100644 internal/ipfeed/output/parquet_test.go create mode 100644 internal/ipfeed/parse/csv.go create mode 100644 internal/ipfeed/parse/json_atlassian.go create mode 100644 internal/ipfeed/parse/json_aws.go create mode 100644 internal/ipfeed/parse/json_azure.go create mode 100644 internal/ipfeed/parse/json_fastly.go create mode 100644 internal/ipfeed/parse/json_github.go create mode 100644 internal/ipfeed/parse/json_m365.go create mode 100644 internal/ipfeed/parse/json_oci.go create mode 100644 internal/ipfeed/parse/json_prefixes.go create mode 100644 internal/ipfeed/parse/json_salesforce.go create mode 100644 internal/ipfeed/parse/opts.go create mode 100644 internal/ipfeed/parse/parse_bench_test.go create mode 100644 internal/ipfeed/parse/parse_test.go create mode 100644 internal/ipfeed/parse/registry.go create mode 100644 internal/ipfeed/parse/text_cidr.go create mode 100644 internal/ipfeed/s3/uploader.go create mode 100644 internal/ipfeed/s3/uploader_test.go create mode 100644 internal/ipfeed/summary/summary.go create mode 100644 internal/ipfeed/telemetry/otel.go create mode 100644 pkg/ipasn/ipasn.go create mode 100644 pkg/ipasn/ipasn_test.go diff --git a/buf.lock b/buf.lock index a548cef..021e5d6 100644 --- a/buf.lock +++ b/buf.lock @@ -2,8 +2,8 @@ version: v2 deps: - name: buf.build/bufbuild/protovalidate - commit: 435963d1631043e694e56e6bcc3c79c3 - digest: b5:f4ea07ad2dd94bd7243562f9908b9fb104feef8076040c89d9f7c1dedc074de4d4ce2b997686ef4400f3eccb765a7cfc20ed4acdd70b9a3699351245c61dba97 + commit: 511051f7f4374c3ca873b53ae68a9288 + digest: b5:a4a2d4d808a25984cced60769c822c5d496ef0b740f56ac0c9e6b97aaa25b86a9332a00ffd74e0cd202be29e91bd3edfb0bf2ba4dacfe48ff2d8217f9986e3c8 - name: buf.build/googleapis/googleapis commit: c17df5b2beca46928cc87d5656bd5343 digest: b5:648a01e0170d4512dea7d564016165decd1ed6e34bef79fe54753e51ad7e27545709ad9157d7551270147d551155c595a2fb0bf5bb33b1c83040ddbce915c604 diff --git a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto index 7db8944..0ed3491 100644 --- a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto +++ b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto @@ -181,6 +181,12 @@ message XtcpFlatRecord { uint32 inet_diag_msg_uid = 1016; uint32 inet_diag_msg_inode = 1017; + // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range + // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the + // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the + // destination IP is not in the feed set. + string inet_diag_msg_socket_dest_network_owner = 1018; + // might want to put more here // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql index fd27ffa..24b17df 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql @@ -116,6 +116,7 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), + inet_diag_msg_socket_dest_network_owner LowCardinality(String), inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql index e786a50..b2fb4b1 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql @@ -111,6 +111,7 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), + inet_diag_msg_socket_dest_network_owner LowCardinality(String), inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), diff --git a/cmd/ipfeed-collector/DESIGN.md b/cmd/ipfeed-collector/DESIGN.md new file mode 100644 index 0000000..2d67c23 --- /dev/null +++ b/cmd/ipfeed-collector/DESIGN.md @@ -0,0 +1,357 @@ +# ipfeed-collector — Design + +## Purpose + +`ipfeed-collector` fetches the authoritative cloud / CDN / SaaS **IP-range +feeds** catalogued in the "Authoritative IP Address Sources" document, +normalizes every feed into a single record schema, and produces one combined +**Parquet** file that is uploaded to S3 under a timestamped key. The result is +an **IP → provider / service / region** classification dataset that can be +refreshed on a schedule (daily polling is reasonable; some feeds change less +often but polling is a cheap safety net). + +The tool is intentionally a **self-contained Go module** living under +`tools/ipfeed-collector/` in the `runpod/xtcp2` packaging repo. It does not +import the upstream `randomizedcoder/xtcp2` Go packages (they are consumed here +only as a Nix flake input), so it re-implements the small helpers it needs. + +## Goals + +1. Download many feeds concurrently, with **retries + full-jitter exponential + backoff**. +2. **Parse** each feed — formats vary widely (JSON with many schemas, CSV, + plain-text CIDR lists, and one that requires URL discovery) — into a common + normalized record. +3. Aggregate into a single combined dataset and write it as **Parquet**. +4. **Upload to S3** with filename `YYYY-MM-DD-HH-MM.parquet` (UTC). +5. **OpenTelemetry (OTLP)** metrics + traces and **structured slog** logging. +6. Emit a **run summary**: files processed, records processed, with explicit + **positive/negative boundaries** (valid vs rejected records), per-source and + in total. +7. Make sources **easy to add/remove**: one config file per source in a + directory, iterated in parallel. + +## Non-goals + +- Building an IP-lookup service or query API (this only produces the dataset). +- ASN/RPKI/BGP enrichment (Tier C in the source doc) — future work. +- Diffing / alerting on large changes between runs — noted as a follow-up. + +## Architecture + +``` +sources/*.yaml ──▶ config.Load ──▶ []Source + │ (bounded worker pool, -concurrency) + ▼ + ┌── per source ────────────────────────────────┐ + │ fetch.Get (retry + backoff, ETag, discover) │ + │ │ raw bytes │ + │ ▼ │ + │ parse.Registry[source.Parser].Parse ──▶ rows │ + └────────────────────────────────┬──────────────┘ + ▼ + combine.Combine (validate CIDRs, +/- boundaries) + ▼ + output.WriteParquet (YYYY-MM-DD-HH-MM.parquet) + ▼ + s3.Upload (minio-go v7) summary.Print +``` + +Telemetry (OTel) and logging (slog) are threaded through every stage. + +## Normalized record schema + +Derived from the source document's recommended schema. Parquet columns: + +| column | notes | +|---|---| +| `prefix` | canonical CIDR string (validated) | +| `ip_version` | `4` or `6` | +| `network_owner` | who owns the routed space (e.g. `aws`) | +| `service_operator` | who operates the service (may differ from owner) | +| `provider` | source's provider label | +| `service` | service tag when the feed provides one | +| `product` | product/scope when provided | +| `region` | region/location when provided | +| `network_border_group` | AWS-specific, else empty | +| `direction` | ingress/egress when provided | +| `source_name` | source config `name` | +| `source_type` | provenance: `provider_feed`, `provider_api`, `provider_documentation`, … | +| `source_url` | feed URL actually fetched | +| `source_timestamp` | feed-declared publish time when available | +| `retrieved_at` | fetch time (UTC) | +| `confidence` | e.g. `authoritative` | + +Overlapping records are **kept** — an address can legitimately be AWS-owned and +Atlassian-operated at once. We do not collapse to one provider per prefix. + +## Source configuration (one YAML per feed) + +```yaml +name: aws-ip-ranges +provider: aws +url: https://ip-ranges.amazonaws.com/ip-ranges.json +parser: aws_ip_ranges # key into the parser registry +source_type: provider_feed +confidence: authoritative +defaults: # merged into every record from this feed + network_owner: aws + service_operator: aws +discover: none # or "azure_download_page" +parser_opts: {} # parser-specific options (CSV columns, etc.) +enabled: true +``` + +Adding a feed = drop a new YAML in `sources/`. Removing = delete it (or set +`enabled: false`). The tool globs `sources/*.yaml`, validates each config, and +fans work out across a bounded worker pool. + +## Parsers + +A registry maps the `parser:` key to a `Parser` implementation. Simple shapes +are handled by config-driven generic parsers; novel JSON schemas get a small +dedicated parser. + +| parser key | feeds | shape | +|---|---|---| +| `text_cidr` | Cloudflare v4/v6 | one CIDR per line | +| `csv` | DigitalOcean, Apple Private Relay, AWS geo-feed | column map in `parser_opts` | +| `aws_ip_ranges` | AWS | `prefixes[]`/`ipv6_prefixes[]` + service/region/network_border_group | +| `gcp_ipranges` | GCP cloud.json/goog.json | `prefixes[].ipv4Prefix/ipv6Prefix`, scope, service | +| `oci` | Oracle | `regions[].cidrs[].cidr` + tags | +| `fastly` | Fastly | `addresses[]` + `ipv6_addresses[]` | +| `github_meta` | GitHub `/meta` | object of named arrays → `service` | +| `atlassian` | Atlassian | `items[]` w/ cidr, product, region, direction | +| `salesforce` | Salesforce Hyperforce | prefixes + direction | +| `applebot` / `google_crawlers` | Apple, Google crawlers | `prefixes[].ipv4Prefix/ipv6Prefix` | +| `m365` | Microsoft 365 | areas array, each with `ips[]` + serviceArea | +| `azure_service_tags` | Azure | discover current dated JSON, then `values[].properties.addressPrefixes` | + +New provider with a novel schema = add one `parse/json_x.go`, register it, add a +YAML. New feed that reuses an existing shape = YAML only. + +## Fetch: retries, backoff, robustness + +- A single reused `*http.Client` with a configured timeout; per-request + `context.WithTimeout` + `http.NewRequestWithContext`. +- **Full-jitter exponential backoff** on retryable failures (network errors, + timeouts, HTTP 5xx / 429): window `= base << (attempt-1)` clamped to a cap; + the actual sleep is drawn uniformly in `[0, window]` from `crypto/rand`, and + the sleep is context-aware. Configurable `-max-attempts`, `-backoff-base`, + `-backoff-cap`. The jitter and sleep are injectable seams so tests are + deterministic and never actually sleep. +- Optional `ETag` / `Last-Modified` conditional requests (per-source state); + a `304 Not Modified` reuses the prior parse where a state file exists. +- **Never accept an empty/invalid response**: a non-2xx status, or a body that + yields zero valid records, marks that source **failed** — it contributes + nothing to the combined dataset. + +## Combine + positive/negative boundaries + +- Each parsed row's `prefix` is validated with `net/netip.ParsePrefix`. +- **Positive (+)** = a valid CIDR that passes validation → included in output. +- **Negative (−)** = rejected → counted with a bounded reason enum so metric + cardinality stays safe (raw error text is never used as a label): + `ParseError`, `Empty`, `Duplicate`, `SourceFailed`. +- The combined dataset is written only if at least `-min-successful-sources` + succeeded, so a bad run never overwrites good data downstream. + +## Output + S3 upload + +- Parquet written via `github.com/parquet-go/parquet-go` to `-out-dir`, named + `YYYY-MM-DD-HH-MM.parquet` in **UTC** (e.g. `2026-09-09-14-30.parquet`). + `-out-file` overrides this with an exact path (its basename becomes the upload + object name); `-out-dir` is then ignored. This is the "local file" workflow: + pair it with `-no-upload` to produce a known-named Parquet and skip S3. +- Upload via **minio-go/v7**: endpoint scheme stripped to a bare host, `Secure` + derived from the scheme, `credentials.NewStaticV4`, region default + `us-east-1`. The secret supports the Docker `_FILE` convention + (`-s3-secret-key-file`); secrets are never logged. Optional `BucketExists` + probe, skippable for write-only keys (`-s3-skip-bucket-probe`). +- Credentials/region resolve flag > `IPFEED_S3_*` env > standard `AWS_*` env + (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`) > default, so an + existing AWS SDK/CLI environment works unmodified. +- The uploader sits behind a small interface so tests use a fake. The S3 key is + `<-s3-prefix>/` (the timestamped name, or the `-out-file` basename). +- `-no-upload` performs a dry run (local Parquet only). + +## Telemetry (OTel / OTLP) + +- OTLP metric + trace exporters via the OTel SDK; endpoint from the standard + `OTEL_EXPORTER_OTLP_ENDPOINT` env. Resource `service.name=ipfeed-collector`. + Providers are flushed/shut down gracefully at exit. +- Instruments (attributes `source`, `provider`): counters `fetch.bytes`, + `fetch.attempts`, `fetch.failures`, `records.valid`, `records.invalid`, + `upload.bytes`, and `cycles` (attribute `outcome=success|failure`, for daemon + health); histograms `fetch.duration`, `parse.duration`; gauge + `sources.succeeded`. +- Trace spans: a root run span, a per-source span (with fetch/parse children), + and combine + upload spans. + +## Logging + +Structured `slog` (JSON handler); verbosity via `-v` / `-debug`. Common fields: +`source`, `url`, `status`, `bytes`, `dur`. Secrets are never logged. + +## Run summary + +Printed to stdout and logged at end — a per-source table plus totals showing +files processed, records processed, and the +valid / −rejected boundaries; +process exits non-zero if fewer than `-min-successful-sources` succeeded. + +## Run modes (single-shot & daemon) + +The command supports two modes so the same binary serves cron jobs and +long-running services. + +- **Single-shot** (default): `run` performs exactly one collection cycle and + returns; `main` maps a shortfall below `-min-successful-sources` to a non-zero + exit. This is the cron / CI / manual path. +- **Daemon** (`-daemon`): the long-lived collaborators (telemetry, HTTP client) + are built **once**, then `runDaemon` executes a cycle immediately and repeats + every `-interval` (default `6h`). Design points: + - **Signals:** the root context comes from `signal.NotifyContext` on + `SIGINT`/`SIGTERM`; on signal the loop finishes the in-flight cycle, logs + `daemon stopping`, shuts telemetry down, and exits 0. + - **No overlap:** cycles run sequentially on a single `time.Ticker` loop, so a + slow cycle can never overlap the next tick. Because Go's `select` gives no + priority between a ready tick and a cancelled context, the tick branch + re-checks `ctx.Err()` before starting another cycle — cancellation is + authoritative and there is no spurious final cycle. + - **Fault tolerance:** a failed cycle is logged and the loop continues (a + transient upstream outage does not kill the daemon). Each cycle records the + `cycles` counter with `outcome=success|failure`. + - **Hot reload:** every cycle re-globs `sources/`, so feeds can be added or + removed without restarting. + +`runDaemon` takes plain `collect`/`ready` function seams (no telemetry or HTTP +types) so it is tested deterministically: the fake `collect` cancels the context +after N calls, letting the test assert exact cycle counts and readiness +transitions without sleeping on real timers. + +### Health endpoints + +When `-http-addr` is set, the daemon starts an HTTP server (via the `health` +package) exposing `/healthz` (liveness — always `200` once bound) and `/readyz` +(readiness — `200` only after ≥1 successful cycle, else `503`). Readiness is an +`atomic.Bool` flipped by the daemon after each successful cycle, letting an +orchestrator hold traffic/alerts until the first dataset exists. `Start` binds +the listener synchronously so a bad `-http-addr` fails fast; serving runs in a +background goroutine and is stopped by `Shutdown` on exit. + +## Configuration (flags + env) + +Configuration is stdlib `flag` with an `IPFEED_*` environment-variable fallback +per flag. Precedence is **CLI flag > `IPFEED_*` env > built-in default**. The S3 +credential and region flags insert the standard `AWS_*` names between their +`IPFEED_S3_*` env and the default (**flag > `IPFEED_S3_*` > `AWS_*` > default**). +An invalid env value falls back to the built-in default rather than erroring, so +a malformed variable cannot crash-loop the daemon. Daemon mode additionally +validates `-interval > 0` at startup. See the README for the full flag ↔ env +mapping. + +## Testing + +All unit tests are **table-driven**; each row carries a `name`, a +human-readable `desc`, the input, `want`, and `wantErr` (expected outcome), and +every table explicitly covers **positive, negative, boundary, and corner** +cases (see the repo test standard). Parser tables use small `testdata/` +fixtures; fetch/backoff and S3 tests use injected seams and fakes so they are +deterministic and offline. + +### Race tests + +Concurrency is exercised under the Go race detector (`go test -race ./...`), +with tests that give it real shared state to inspect: the health server's +`atomic.Bool` readiness (many goroutines calling `SetReady()` while others +serve `/readyz`), the `collectOnce` worker-pool fan-in (concurrent +`processSource` results aggregated into shared slices/summary), and concurrent +`fetch.Client.Get` calls sharing one `*Client`. The race detector **requires +cgo**, so the Nix `race` check compiles with `CGO_ENABLED=1` and a C toolchain +on PATH — the one place the pipeline diverges from the default `CGO_ENABLED=0` +static build. + +### Benchmarks + +Go benchmarks cover the hot paths: `internal/parse` (per-format decode over +`testdata/` fixtures), `internal/combine` `Validate` (CIDR parse + +canonicalization + dedup over 1e2 / 1e4 / 1e5 records — the hottest path at +~17k+ records/run), and `internal/output` `WriteParquet` throughput. Each uses +`b.ReportAllocs()` and size-swept `b.Run` sub-benchmarks (the table-driven +analog for benches). Perf *numbers* are gathered on a real host with +`benchstat`; the Nix `bench-smoke` check only runs `-benchtime=1x` to prove +benchmarks build and execute (the build sandbox is not a stable perf +environment). + +## Build & packaging (Nix) + +The tool ships a **self-contained flake** under `tools/ipfeed-collector/` +(alongside its own `go.mod`), mirroring the upstream `xtcp2` Nix layout but +without its protos/giouring/microvm/flavor machinery — this is a single +standalone binary. The repo-root RunPod flake (which re-exports the upstream +s3parquet image) is intentionally left untouched. + +``` +tools/ipfeed-collector/ + flake.nix # thin orchestrator -> ./nix (eachSystem x86_64-linux) + nix/ + default.nix # per-system aggregator: packages, devShells, checks + versions.nix # Go pin + buildVariants {debug, compact} + goVendorHash + packages.nix # dev tool list + devshell.nix # `nix develop` + helpers, via `ipfeed-help` + lib/mkGoBinary.nix # reusable buildGoModule wrapper (consumed by OCI) + lib/mkOciImage.nix # scratch streamLayeredImage wrapper + containers/default.nix # oci-ipfeed-collector (compact) + -debug + checks/default.nix # gofmt, vet, test, race, bench-smoke +``` + +### Build variants + +`versions.nix` defines two variants that drive `mkGoBinary`: + +| variant | ldflags | strip | use | +|---|---|---|---| +| `debug` | none (keeps symbols + DWARF) | no | delve / `pprof` symbolization, post-mortems | +| `compact` | `-s -w` | yes (`binutils strip`) | production default; smallest image | + +Builds are static (`CGO_ENABLED=0`, tags `netgo,osusergo`) with `-trimpath` and +`-X main.{version,commit,date}` injected. The Go toolchain is pinned to match +`go.mod` (1.26.x). + +### Reusable Go-binary derivation + +`lib/mkGoBinary.nix` wraps `buildGoModule` (overridden to the pinned Go), +building `cmd/ipfeed-collector` with the requested variant. It is the single +source of the compiled binary and is **reused by the OCI images** so the image +contents are byte-identical to `nix build .#ipfeed-collector`. The module has +no local `replace` directives, so no `go.mod` patching is needed; `vendorHash` +lives in `versions.nix` (bootstrap with `lib.fakeHash`, then paste the reported +`got: sha256-…`). + +### OCI images + +`lib/mkOciImage.nix` uses `dockerTools.streamLayeredImage` over a scratch base +plus `dockerTools.caCertificates` (HTTPS to real feeds and S3 needs a CA +bundle; `SSL_CERT_FILE` is pointed at it). Two images: + +- `oci-ipfeed-collector` — compact variant, `tag=latest`. +- `oci-ipfeed-collector-debug` — debug variant, `tag=debug`. + +Entrypoint is `/bin/ipfeed-collector` with `Cmd=["-daemon"]`, so a bare +`docker run` starts the service (all `IPFEED_*` env overridable at runtime); the +health port is exposed by convention. The image carries a Docker **HEALTHCHECK** +(`/bin/ipfeed-collector -healthcheck`) — a self-probe mode that issues an HTTP +GET to `127.0.0.1/readyz` and exits `0`/`1`, so the scratch image +needs no shell or `curl` (mirrors upstream xtcp2's `-healthcheck`). + +Load with `nix build .#oci-ipfeed-collector && ./result | docker load`. + +### Dev shell + +`nix develop` lands in a shell with the pinned Go plus `gopls`, +`golangci-lint`, `delve`, `benchstat`, and `nixfmt`. Helper functions +(discoverable via `ipfeed-help`) wrap the common loops: `build`, `test`, +`test-race`, `bench`, `bench-compare`, `lint`. + +Wiring the image into the RunPod release pipeline and adding a committed PGO +profile are noted follow-ups, out of scope for the initial packaging. diff --git a/cmd/ipfeed-collector/README.md b/cmd/ipfeed-collector/README.md new file mode 100644 index 0000000..3a0fcbc --- /dev/null +++ b/cmd/ipfeed-collector/README.md @@ -0,0 +1,187 @@ +# ipfeed-collector + +Fetches authoritative cloud / CDN / SaaS **IP-range feeds**, normalizes them +into one schema, writes a combined **Parquet** file named `YYYY-MM-DD-HH-MM` +(UTC), and uploads it to S3. Emits OpenTelemetry (OTLP) metrics/traces, +structured `slog` logs, and an end-of-run summary with positive/negative +(valid vs rejected) record boundaries. + +See [DESIGN.md](./DESIGN.md) for the full design. + +## Build & test + +```sh +cd tools/ipfeed-collector +go build ./... +go vet ./... +go test ./... +go test -race ./... # race detector (needs cgo) +go test -bench=. -benchmem -run='^$' ./... # benchmarks +``` + +## Build with Nix + +The tool has a self-contained flake. From `tools/ipfeed-collector/`: + +```sh +nix develop # dev shell (Go, gopls, golangci-lint, delve); run `ipfeed-help` +nix build .#ipfeed-collector # static binary (compact: -s -w + strip) +nix build .#ipfeed-collector-debug # static binary with symbols + DWARF (delve/pprof) +nix build .#oci-ipfeed-collector # scratch OCI image (compact) +nix build .#oci-ipfeed-collector-debug # scratch OCI image (debug) +./result | docker load # load a built image +nix flake check # gofmt + vet + test + race + bench-smoke +``` + +The OCI images are scratch + a CA bundle; entrypoint is `/bin/ipfeed-collector` +with a default `-daemon` arg and a Docker HEALTHCHECK wired to `-healthcheck`. +See [DESIGN.md](./DESIGN.md) "Build & packaging (Nix)" for details. + +## Run + +Dry run (no upload) against the bundled sources: + +```sh +go run ./cmd/ipfeed-collector -sources-dir ./sources -out-dir /tmp -no-upload +``` + +Write to an exact local path and skip S3 entirely: + +```sh +go run ./cmd/ipfeed-collector -sources-dir ./sources -out-file /data/ipfeeds.parquet -no-upload +``` + +Full run with upload: + +```sh +go run ./cmd/ipfeed-collector \ + -sources-dir ./sources -out-dir /tmp \ + -s3-endpoint https://s3.example.com -s3-bucket ipfeeds \ + -s3-prefix ipranges -s3-access-key "$KEY" -s3-secret-key-file /run/secrets/s3 +``` + +OTLP export is enabled automatically when `OTEL_EXPORTER_OTLP_ENDPOINT` is set; +otherwise the tool runs with no collector attached. + +## Modes + +The tool runs in two modes: + +- **Single-shot** (default): performs one collection cycle — fetch, parse, + combine, write, upload — then exits. The process exit code is non-zero if + fewer than `-min-successful-sources` succeeded. Use this from cron or a + one-off invocation. +- **Daemon** (`-daemon`): runs one cycle immediately, then repeats every + `-interval` (default `6h`) until it receives `SIGINT`/`SIGTERM`, at which + point it stops after the in-flight cycle and exits 0. Cycles run + sequentially (never overlapping), and `sources/` is reloaded each cycle, so + feeds can be added or removed without a restart. A failed cycle is logged + and the loop continues. + +```sh +# daemon, every 6h, health endpoints on :8080 +go run ./cmd/ipfeed-collector -daemon -interval 6h -http-addr :8080 \ + -sources-dir ./sources -out-dir /var/lib/ipfeed -no-upload +``` + +### Health endpoints (daemon) + +When `-http-addr` is set, the daemon serves two endpoints: + +| path | meaning | +|---|---| +| `/healthz` | liveness — always `200 ok` once the server is listening | +| `/readyz` | readiness — `200 ready` only after ≥1 successful cycle, else `503 not ready` | + +`-interval` must be `> 0` in daemon mode; the tool errors at startup otherwise. + +`-healthcheck` is a self-probe mode: it issues a GET to +`127.0.0.1/readyz` (defaulting the port to `8080`) and exits `0` if +ready, else `1`. It starts no telemetry and runs no collection — it exists so a +scratch container can define a Docker HEALTHCHECK without a shell or `curl`. +Run it in a separate process from the daemon, e.g. `ipfeed-collector -healthcheck`. + +## Configuration via environment + +Every flag has an `IPFEED_*` environment-variable fallback. Precedence is: +**command-line flag > `IPFEED_*` env var > built-in default**. An invalid env +value (e.g. an unparseable duration) falls back to the built-in default rather +than failing, which keeps a bad env var from crash-looping the daemon. + +| flag | env var | +|---|---| +| `-sources-dir` | `IPFEED_SOURCES_DIR` | +| `-out-dir` | `IPFEED_OUT_DIR` | +| `-out-file` | `IPFEED_OUT_FILE` | +| `-concurrency` | `IPFEED_CONCURRENCY` | +| `-timeout` | `IPFEED_TIMEOUT` | +| `-max-attempts` | `IPFEED_MAX_ATTEMPTS` | +| `-backoff-base` | `IPFEED_BACKOFF_BASE` | +| `-backoff-cap` | `IPFEED_BACKOFF_CAP` | +| `-min-successful-sources` | `IPFEED_MIN_SUCCESSFUL_SOURCES` | +| `-no-upload` | `IPFEED_NO_UPLOAD` | +| `-v` / `-debug` | `IPFEED_VERBOSE` / `IPFEED_DEBUG` | +| `-daemon` | `IPFEED_DAEMON` | +| `-interval` | `IPFEED_INTERVAL` | +| `-http-addr` | `IPFEED_HTTP_ADDR` | +| `-healthcheck` | `IPFEED_HEALTHCHECK` | +| `-s3-endpoint` | `IPFEED_S3_ENDPOINT` | +| `-s3-bucket` | `IPFEED_S3_BUCKET` | +| `-s3-region` | `IPFEED_S3_REGION` (then `AWS_REGION`) | +| `-s3-prefix` | `IPFEED_S3_PREFIX` | +| `-s3-access-key` | `IPFEED_S3_ACCESS_KEY` (then `AWS_ACCESS_KEY_ID`) | +| `-s3-secret-key` | `IPFEED_S3_SECRET_KEY` (then `AWS_SECRET_ACCESS_KEY`) | +| `-s3-secret-key-file` | `IPFEED_S3_SECRET_KEY_FILE` | +| `-s3-skip-bucket-probe` | `IPFEED_S3_SKIP_BUCKET_PROBE` | + +The S3 secret is best supplied as a file (`-s3-secret-key-file` / +`IPFEED_S3_SECRET_KEY_FILE`, the Docker `_FILE` secret convention); it is +trimmed and never logged. + +The credential and region flags also fall back to the standard AWS environment +names (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`) *after* their +`IPFEED_S3_*` counterparts, so an existing AWS SDK/CLI environment works without +extra configuration. Full precedence: **flag > `IPFEED_S3_*` > `AWS_*` > +default**. + +### Key flags + +| flag | default | purpose | +|---|---|---| +| `-sources-dir` | `./sources` | directory of per-source YAML files | +| `-out-dir` | `$TMPDIR` | directory for the timestamped Parquet file (ignored when `-out-file` is set) | +| `-out-file` | — | exact local path for the Parquet file; overrides `-out-dir` and its timestamped name | +| `-concurrency` | `8` | max concurrent source fetches | +| `-timeout` | `30s` | per-request HTTP timeout | +| `-max-attempts` / `-backoff-base` / `-backoff-cap` | `10` / `1s` / `1h` | retry + full-jitter backoff | +| `-min-successful-sources` | `1` | minimum OK sources before writing/uploading | +| `-daemon` | `false` | run continuously, repeating every `-interval` | +| `-interval` | `6h` | daemon collection interval (must be `> 0` with `-daemon`) | +| `-http-addr` | — | daemon health endpoint address, e.g. `:8080` (empty disables) | +| `-healthcheck` | `false` | probe a running daemon's `/readyz` and exit 0/1 (container HEALTHCHECK) | +| `-no-upload` | `false` | write Parquet locally only | +| `-s3-*` | — | endpoint, bucket, region, prefix, access key, secret (+ `-s3-secret-key-file`) | +| `-v` / `-debug` | `false` | debug logging | + +## Adding / removing a source + +Sources are one YAML file per feed under `sources/`. To add a feed, drop in a +new file; to remove one, delete it or set `enabled: false`. + +```yaml +name: my-feed +provider: acme +url: https://acme.example/ips.json +parser: text_cidr # a key from the parser registry (see DESIGN.md) +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: acme + service_operator: acme +parser_opts: {} # parser-specific options (e.g. CSV column indices) +enabled: true +``` + +If a feed uses a shape no existing parser handles, add a small parser in +`internal/parse/` and register it under a new key; otherwise a YAML file is all +that is needed. diff --git a/cmd/ipfeed-collector/main.go b/cmd/ipfeed-collector/main.go new file mode 100644 index 0000000..d96dd93 --- /dev/null +++ b/cmd/ipfeed-collector/main.go @@ -0,0 +1,546 @@ +// Command ipfeed-collector fetches cloud/CDN/SaaS IP-range feeds defined as +// one YAML file per source, normalizes them into a single schema, writes a +// timestamped Parquet file, and uploads it to S3. It emits OpenTelemetry +// metrics/traces, structured slog logs, and an end-of-run summary reporting +// files and records processed with positive/negative boundaries. +// +// It runs in two modes: single-shot (the default — one collection cycle, then +// exit) and daemon (-daemon — run immediately, then repeat every -interval, +// serving /healthz and /readyz when -http-addr is set). Every flag also reads +// an IPFEED_* environment variable when the flag is not given, so the daemon +// is easy to configure from a systemd unit or container. +package main + +import ( + "context" + "flag" + "fmt" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "path/filepath" + "sort" + "strconv" + "sync" + "syscall" + "time" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" + "go.opentelemetry.io/otel/trace" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/asnmap" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/combine" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/config" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/fetch" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/health" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/output" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/parse" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/s3" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/summary" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/telemetry" +) + +type flags struct { + sourcesDir string + outDir string + outFile string + concurrency int + timeout time.Duration + maxAttempts int + backoffBase time.Duration + backoffCap time.Duration + minSuccess int + noUpload bool + verbose bool + debug bool + + daemon bool + interval time.Duration + httpAddr string + healthcheck bool + version bool + + s3 s3.Config + s3SecretKeyFile string +} + +// env fallback helpers: an unset flag defaults to its IPFEED_* env var when +// present, else the built-in default. An invalid env value falls back to the +// built-in default rather than failing. A flag given on the command line +// always overrides both (that is how flag defaults work). +func envStr(key, def string) string { + if v, ok := os.LookupEnv(key); ok { + return v + } + return def +} + +func envInt(key string, def int) int { + if v, ok := os.LookupEnv(key); ok { + if n, err := strconv.Atoi(v); err == nil { + return n + } + } + return def +} + +func envBool(key string, def bool) bool { + if v, ok := os.LookupEnv(key); ok { + if b, err := strconv.ParseBool(v); err == nil { + return b + } + } + return def +} + +func envDur(key string, def time.Duration) time.Duration { + if v, ok := os.LookupEnv(key); ok { + if d, err := time.ParseDuration(v); err == nil { + return d + } + } + return def +} + +func parseFlags(args []string) (flags, error) { + var f flags + fs := flag.NewFlagSet("ipfeed-collector", flag.ContinueOnError) + fs.StringVar(&f.sourcesDir, "sources-dir", envStr("IPFEED_SOURCES_DIR", "./sources"), "directory of per-source YAML files") + fs.StringVar(&f.outDir, "out-dir", envStr("IPFEED_OUT_DIR", os.TempDir()), "local directory for the Parquet file (ignored when -out-file is set)") + fs.StringVar(&f.outFile, "out-file", envStr("IPFEED_OUT_FILE", ""), "exact local path for the Parquet file; overrides -out-dir and its timestamped name") + fs.IntVar(&f.concurrency, "concurrency", envInt("IPFEED_CONCURRENCY", 8), "max concurrent source fetches") + fs.DurationVar(&f.timeout, "timeout", envDur("IPFEED_TIMEOUT", 30*time.Second), "per-request HTTP timeout") + fs.IntVar(&f.maxAttempts, "max-attempts", envInt("IPFEED_MAX_ATTEMPTS", 10), "max fetch attempts per source") + fs.DurationVar(&f.backoffBase, "backoff-base", envDur("IPFEED_BACKOFF_BASE", time.Second), "base backoff window") + fs.DurationVar(&f.backoffCap, "backoff-cap", envDur("IPFEED_BACKOFF_CAP", time.Hour), "max backoff window") + fs.IntVar(&f.minSuccess, "min-successful-sources", envInt("IPFEED_MIN_SUCCESSFUL_SOURCES", 1), "minimum OK sources required to write/upload") + fs.BoolVar(&f.noUpload, "no-upload", envBool("IPFEED_NO_UPLOAD", false), "write Parquet locally but skip S3 upload") + fs.BoolVar(&f.verbose, "v", envBool("IPFEED_VERBOSE", false), "verbose (debug) logging") + fs.BoolVar(&f.debug, "debug", envBool("IPFEED_DEBUG", false), "debug logging (alias of -v)") + + fs.BoolVar(&f.daemon, "daemon", envBool("IPFEED_DAEMON", false), "run continuously, repeating every -interval") + fs.DurationVar(&f.interval, "interval", envDur("IPFEED_INTERVAL", 6*time.Hour), "daemon collection interval") + fs.StringVar(&f.httpAddr, "http-addr", envStr("IPFEED_HTTP_ADDR", ""), "daemon health endpoint address, e.g. :8080 (empty disables)") + fs.BoolVar(&f.healthcheck, "healthcheck", envBool("IPFEED_HEALTHCHECK", false), "probe a running daemon's /readyz and exit 0 (ready) or 1; used as the container HEALTHCHECK") + fs.BoolVar(&f.version, "version", false, "print build version and exit") + + fs.StringVar(&f.s3.Endpoint, "s3-endpoint", envStr("IPFEED_S3_ENDPOINT", ""), "S3 endpoint (may include scheme)") + fs.StringVar(&f.s3.Bucket, "s3-bucket", envStr("IPFEED_S3_BUCKET", ""), "S3 bucket") + // Credentials/region fall back to the standard AWS_* names after the + // IPFEED_S3_* ones, so an AWS SDK/CLI environment works out of the box. + // Precedence: flag > IPFEED_S3_* > AWS_* > built-in default. + fs.StringVar(&f.s3.Region, "s3-region", envStr("IPFEED_S3_REGION", envStr("AWS_REGION", "us-east-1")), "S3 region") + fs.StringVar(&f.s3.Prefix, "s3-prefix", envStr("IPFEED_S3_PREFIX", ""), "S3 key prefix") + fs.StringVar(&f.s3.AccessKey, "s3-access-key", envStr("IPFEED_S3_ACCESS_KEY", envStr("AWS_ACCESS_KEY_ID", "")), "S3 access key") + fs.StringVar(&f.s3.SecretKey, "s3-secret-key", envStr("IPFEED_S3_SECRET_KEY", envStr("AWS_SECRET_ACCESS_KEY", "")), "S3 secret key (prefer -s3-secret-key-file)") + fs.StringVar(&f.s3SecretKeyFile, "s3-secret-key-file", envStr("IPFEED_S3_SECRET_KEY_FILE", ""), "path to a file holding the S3 secret key") + fs.BoolVar(&f.s3.SkipBucketProbe, "s3-skip-bucket-probe", envBool("IPFEED_S3_SKIP_BUCKET_PROBE", false), "skip the BucketExists probe") + + if err := fs.Parse(args); err != nil { + return flags{}, err + } + if f.daemon && f.interval <= 0 { + return flags{}, fmt.Errorf("-interval must be > 0 in daemon mode") + } + return f, nil +} + +// readyzURL turns a health-server bind address into the loopback /readyz URL a +// self-probe should hit. An empty addr defaults to :8080 (the image's exposed +// port convention); a wildcard/empty host becomes 127.0.0.1 since the probe +// runs inside the same container. +func readyzURL(addr string) string { + if addr == "" { + addr = ":8080" + } + host, port, err := net.SplitHostPort(addr) + if err != nil { + // Not host:port (e.g. a bare port) — treat the whole thing as the port. + host, port = "", addr + } + if host == "" || host == "0.0.0.0" || host == "::" { + host = "127.0.0.1" + } + return "http://" + net.JoinHostPort(host, port) + "/readyz" +} + +// healthcheck issues a GET to url and returns nil iff the response status is +// 200. Any transport error, timeout, or non-200 status is an error. It is a +// standalone function (URL in, error out) so it is unit-testable with httptest. +func healthcheck(url string, timeout time.Duration) error { + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + return err + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + return fmt.Errorf("not ready: status %d", resp.StatusCode) + } + return nil +} + +// Build metadata, injected via -ldflags "-X main.commit=... -X main.date=... +// -X main.version=..." by the Nix mkGoBinary derivation. +var ( + commit string + date string + version string +) + +func main() { + f, err := parseFlags(os.Args[1:]) + if err != nil { + os.Exit(2) + } + + if f.version { + fmt.Printf("ipfeed-collector version=%s commit=%s date=%s\n", version, commit, date) + os.Exit(0) + } + + // Healthcheck mode: probe a running daemon's /readyz and exit, without + // starting telemetry or a collection cycle. This is the container + // HEALTHCHECK entrypoint, so a scratch image needs no shell or curl. + if f.healthcheck { + if err := healthcheck(readyzURL(f.httpAddr), 5*time.Second); err != nil { + fmt.Fprintln(os.Stderr, "healthcheck:", err) + os.Exit(1) + } + os.Exit(0) + } + + level := slog.LevelInfo + if f.verbose || f.debug { + level = slog.LevelDebug + } + log := slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: level})) + + if err := run(context.Background(), f, log); err != nil { + log.Error("run failed", "err", err) + os.Exit(1) + } +} + +// deps bundles the long-lived collaborators shared across collection cycles. +type deps struct { + f flags + tel *telemetry.Telemetry + client *fetch.Client + log *slog.Logger +} + +// sourceOutcome bundles a source's valid records with its summary row. +type sourceOutcome struct { + valid []model.Record + result summary.SourceResult +} + +func run(rootCtx context.Context, f flags, log *slog.Logger) error { + tel, err := telemetry.Setup(rootCtx, "ipfeed-collector") + if err != nil { + return fmt.Errorf("telemetry: %w", err) + } + defer func() { //nolint:contextcheck // shutdown must not inherit the already-canceled rootCtx + // Shutdown must not inherit rootCtx, which is typically already canceled + // by the time this defer runs. + sctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := tel.Shutdown(sctx); err != nil { + log.Warn("telemetry shutdown", "err", err) + } + }() + + client := fetch.NewClient(fetch.Options{ + MaxAttempts: f.maxAttempts, + BackoffBase: f.backoffBase, + BackoffCap: f.backoffCap, + Timeout: f.timeout, + }) + d := deps{f: f, tel: tel, client: client, log: log} + + // Cancel work cleanly on SIGINT/SIGTERM. + ctx, stop := signal.NotifyContext(rootCtx, os.Interrupt, syscall.SIGTERM) + defer stop() + + // One cycle, wrapped to record the cycle-outcome metric. Used by both modes. + collect := func(ctx context.Context) error { + err := collectOnce(ctx, d) + outcome := "success" + if err != nil { + outcome = "failure" + } + tel.Cycles.Add(ctx, 1, metric.WithAttributes(attribute.String("outcome", outcome))) + return err + } + + if !f.daemon { + return collect(ctx) + } + + // Daemon: optional health endpoint, then loop. + var ready func() + if f.httpAddr != "" { + hs := health.NewServer(f.httpAddr) + if err := hs.Start(ctx); err != nil { + return fmt.Errorf("health server: %w", err) + } + log.Info("health server listening", "addr", f.httpAddr) + defer func() { //nolint:contextcheck // shutdown must not inherit the already-canceled daemon ctx + // Fresh ctx: the daemon ctx is already canceled during shutdown. + sctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := hs.Shutdown(sctx); err != nil { + log.Warn("health server shutdown", "err", err) + } + }() + ready = hs.SetReady + } + log.Info("daemon started", "interval", f.interval) + return runDaemon(ctx, f.interval, ready, collect, log) +} + +// runDaemon runs collect immediately, then on every interval tick, until ctx +// is canceled. A failed cycle is logged but does not stop the loop; ready is +// invoked after each successful cycle (nil ready is a no-op). It is kept free +// of telemetry/HTTP so it is straightforward to test with fakes. +func runDaemon(ctx context.Context, interval time.Duration, ready func(), collect func(context.Context) error, log *slog.Logger) error { + runCycle := func() { + if err := collect(ctx); err != nil { + log.Error("collection cycle failed", "err", err) + return + } + if ready != nil { + ready() + } + } + + runCycle() + if ctx.Err() != nil { + return nil + } + t := time.NewTicker(interval) + defer t.Stop() + for { + select { + case <-ctx.Done(): + log.Info("daemon stopping") + return nil + case <-t.C: + // select may pick a ready tick even when ctx is already done + // (Go makes no priority guarantee between ready cases), so + // re-check before starting another cycle. + if ctx.Err() != nil { + log.Info("daemon stopping") + return nil + } + runCycle() + } + } +} + +// collectOnce performs one full collection cycle: (re)load sources, fetch and +// parse them concurrently, validate, write the Parquet file, and upload it. +// Sources are reloaded each call so files added/removed under -sources-dir are +// picked up without restarting the daemon. +func collectOnce(ctx context.Context, d deps) error { + f, tel, client, log := d.f, d.tel, d.client, d.log + + sources, err := config.LoadDir(f.sourcesDir) + if err != nil { + return fmt.Errorf("load sources: %w", err) + } + if len(sources) == 0 { + return fmt.Errorf("no enabled sources found in %s", f.sourcesDir) + } + log.Info("loaded sources", "count", len(sources), "dir", f.sourcesDir) + + ctx, span := tel.Tracer.Start(ctx, "cycle") + defer span.End() + + // Fan out over sources with a bounded worker pool. + outcomes := make([]sourceOutcome, len(sources)) + sem := make(chan struct{}, max(1, f.concurrency)) + var wg sync.WaitGroup + for i := range sources { + wg.Go(func() { + sem <- struct{}{} + defer func() { <-sem }() + outcomes[i] = processSource(ctx, client, tel, log, sources[i]) + }) + } + wg.Wait() + + // Aggregate. + var sum summary.Summary + var combined []model.Record + for _, o := range outcomes { + sum.Add(o.result) + combined = append(combined, o.valid...) + } + tel.SourcesSucceeded.Record(ctx, int64(sum.OKCount())) + + // Enrich each record with a representative ASN derived from its owner / + // provider, so the artifact carries prefix -> {asn, network_owner, …} for + // downstream IP->ASN lookups (see internal/ipfeed/asnmap). + asnmap.Annotate(combined) + + if sum.OKCount() < f.minSuccess { + sum.Print(os.Stdout, "", 0) + return fmt.Errorf("only %d/%d sources succeeded (min %d); not writing dataset", + sum.OKCount(), len(sources), f.minSuccess) + } + + // Stable ordering for reproducible output. + sort.Slice(combined, func(i, j int) bool { + if combined[i].Prefix != combined[j].Prefix { + return combined[i].Prefix < combined[j].Prefix + } + return combined[i].SourceName < combined[j].SourceName + }) + + // -out-file names the exact output path; otherwise write a timestamped file + // into -out-dir. The basename is reused as the S3 object name on upload. + now := time.Now().UTC() + filename := output.Filename(now) + outPath := filepath.Join(f.outDir, filename) + if f.outFile != "" { + outPath = f.outFile + filename = filepath.Base(f.outFile) + } + size, err := output.WriteParquet(outPath, combined) + if err != nil { + return fmt.Errorf("write parquet: %w", err) + } + log.Info("wrote parquet", "path", outPath, "records", len(combined), "bytes", size) + + uploadURL := "" + if !f.noUpload { + uploadURL, err = uploadResult(ctx, f, tel, log, outPath, filename, size) + if err != nil { + return fmt.Errorf("upload: %w", err) + } + } + + sum.Print(os.Stdout, uploadURL, size) + return nil +} + +// processSource discovers, fetches, parses, and validates one source. +func processSource(ctx context.Context, client *fetch.Client, tel *telemetry.Telemetry, log *slog.Logger, src config.Source) sourceOutcome { + attrs := metric.WithAttributes( + attribute.String("source", src.Name), + attribute.String("provider", src.Provider), + ) + ctx, span := tel.Tracer.Start(ctx, "source", trace.WithAttributes( + attribute.String("source", src.Name))) + defer span.End() + + res := summary.SourceResult{Name: src.Name} + start := time.Now() + + url, err := client.Discover(ctx, src.Discover, src.URL) + if err != nil { + tel.FetchFailures.Add(ctx, 1, attrs) + res.Note = "discover: " + err.Error() + res.Duration = time.Since(start) + log.Error("discover failed", "source", src.Name, "err", err) + return sourceOutcome{result: res} + } + + fr, err := client.Get(ctx, url, fetch.Conditional{}) + res.HTTPStatus = fr.Status + tel.FetchAttempts.Add(ctx, int64(fr.Attempts), attrs) + res.FetchedBytes = int64(len(fr.Body)) + tel.FetchBytes.Add(ctx, res.FetchedBytes, attrs) + tel.FetchDuration.Record(ctx, time.Since(start).Seconds(), attrs) + if err != nil { + tel.FetchFailures.Add(ctx, 1, attrs) + res.Note = err.Error() + res.Duration = time.Since(start) + log.Error("fetch failed", "source", src.Name, "url", url, "err", err) + return sourceOutcome{result: res} + } + + parser, ok := parse.Get(src.Parser) + if !ok { // validated at load, but guard anyway + res.Note = "unknown parser " + src.Parser + res.Duration = time.Since(start) + return sourceOutcome{result: res} + } + retrievedAt := time.Now().UTC().Format(time.RFC3339) + pstart := time.Now() + records, err := parser.Parse(fr.Body, src.Meta(), retrievedAt) + tel.ParseDuration.Record(ctx, time.Since(pstart).Seconds(), attrs) + if err != nil { + res.Note = "parse: " + err.Error() + res.Duration = time.Since(start) + log.Error("parse failed", "source", src.Name, "err", err) + return sourceOutcome{result: res} + } + res.Parsed = len(records) + + seen := make(map[string]struct{}, len(records)) + cr := combine.Validate(records, seen) + res.Valid = cr.ValidCount() + res.Rejected = cr.RejectedCount() + tel.RecordsValid.Add(ctx, int64(res.Valid), attrs) + tel.RecordsInvalid.Add(ctx, int64(res.Rejected), attrs) + + // Per the update strategy: an empty/invalid response must not be treated + // as success. + if res.Valid == 0 { + res.Note = "no valid records" + res.Duration = time.Since(start) + log.Warn("source produced no valid records", "source", src.Name) + return sourceOutcome{result: res} + } + + res.OK = true + res.Duration = time.Since(start) + log.Info("source ok", "source", src.Name, "valid", res.Valid, "rejected", res.Rejected, + "http", res.HTTPStatus, "bytes", res.FetchedBytes) + return sourceOutcome{valid: cr.Valid, result: res} +} + +// uploadResult builds the S3 client and uploads the Parquet file. +func uploadResult(ctx context.Context, f flags, tel *telemetry.Telemetry, log *slog.Logger, path, filename string, size int64) (string, error) { + cfg := f.s3 + secret, err := s3.SecretFromFile(f.s3SecretKeyFile) + if err != nil { + return "", err + } + if secret != "" { + cfg.SecretKey = secret + } + up, err := s3.New(ctx, cfg) + if err != nil { + return "", err + } + file, err := os.Open(path) + if err != nil { + return "", err + } + defer file.Close() + + key := cfg.Key(filename) + ctx, span := tel.Tracer.Start(ctx, "upload", trace.WithAttributes(attribute.String("key", key))) + defer span.End() + + url, err := up.Put(ctx, key, file, size) + if err != nil { + return "", err + } + tel.UploadBytes.Add(ctx, size) + log.Info("uploaded", "url", url, "bytes", size) + return url, nil +} diff --git a/cmd/ipfeed-collector/main_test.go b/cmd/ipfeed-collector/main_test.go new file mode 100644 index 0000000..042c926 --- /dev/null +++ b/cmd/ipfeed-collector/main_test.go @@ -0,0 +1,342 @@ +package main + +import ( + "context" + "net/http" + "net/http/httptest" + "os" + "sync/atomic" + "testing" + "time" + + "log/slog" +) + +// setOrUnset sets key to val when set is true, otherwise ensures it is unset, +// registering cleanup so the surrounding environment is restored. +func setOrUnset(t *testing.T, key, val string, set bool) { + t.Helper() + prev, had := os.LookupEnv(key) + t.Cleanup(func() { + if had { + os.Setenv(key, prev) //nolint:errcheck,gosec // test env restore; failure is not actionable + } else { + os.Unsetenv(key) //nolint:errcheck,gosec // test env restore; failure is not actionable + } + }) + if set { + os.Setenv(key, val) //nolint:errcheck,gosec // test env setup; failure is not actionable + } else { + os.Unsetenv(key) //nolint:errcheck,gosec // test env setup; failure is not actionable + } +} + +func discardLogger() *slog.Logger { + return slog.New(slog.NewTextHandler(newDiscard(), &slog.HandlerOptions{Level: slog.LevelError})) +} + +type discardWriter struct{} + +func (discardWriter) Write(p []byte) (int, error) { return len(p), nil } +func newDiscard() discardWriter { return discardWriter{} } + +func TestEnvHelpers(t *testing.T) { + t.Run("str", func(t *testing.T) { + tests := []struct { + name, desc, class string + set bool + val, def, want string + }{ + {"positive_set", "positive: env value is used when present", "positive", true, "envv", "def", "envv"}, + {"boundary_unset", "boundary: default is used when unset", "boundary", false, "", "def", "def"}, + {"corner_empty_set", "corner: an explicitly empty env value overrides the default", "corner", true, "", "def", ""}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + const key = "IPFEED_TEST_STR" + setOrUnset(t, key, tc.val, tc.set) + if got := envStr(key, tc.def); got != tc.want { + t.Errorf("%s: got %q, want %q", tc.desc, got, tc.want) + } + }) + } + }) + + t.Run("dur", func(t *testing.T) { + tests := []struct { + name, desc, class, val string + set bool + def, want time.Duration + }{ + {"positive_parse", "positive: a valid duration parses", "positive", "90m", true, time.Hour, 90 * time.Minute}, + {"negative_invalid", "negative: an invalid duration falls back to the default", "negative", "banana", true, time.Hour, time.Hour}, + {"boundary_unset", "boundary: default when unset", "boundary", "", false, 6 * time.Hour, 6 * time.Hour}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + const key = "IPFEED_TEST_DUR" + setOrUnset(t, key, tc.val, tc.set) + if got := envDur(key, tc.def); got != tc.want { + t.Errorf("%s: got %v, want %v", tc.desc, got, tc.want) + } + }) + } + }) + + t.Run("bool", func(t *testing.T) { + const key = "IPFEED_TEST_BOOL" + t.Setenv(key, "true") + if !envBool(key, false) { + t.Error("positive: 'true' should parse to true") + } + t.Setenv(key, "notabool") + if envBool(key, false) { + t.Error("negative: invalid bool should fall back to default (false)") + } + }) +} + +// TestReadyzURL covers address normalization for the self-probe. +func TestReadyzURL(t *testing.T) { + tests := []struct { + name, desc, class, in, want string + }{ + {"positive_hostport", "positive: an explicit host:port is preserved", "positive", + "10.0.0.5:9000", "http://10.0.0.5:9000/readyz"}, + {"boundary_empty", "boundary: empty addr defaults to :8080 on loopback", "boundary", + "", "http://127.0.0.1:8080/readyz"}, + {"corner_wildcard_host", "corner: a wildcard bind host maps to loopback for the probe", "corner", + "0.0.0.0:8080", "http://127.0.0.1:8080/readyz"}, + {"corner_colon_port_only", "corner: a bare :port keeps the port on loopback", "corner", + ":8081", "http://127.0.0.1:8081/readyz"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := readyzURL(tc.in); got != tc.want { + t.Errorf("%s: readyzURL(%q) = %q, want %q", tc.desc, tc.in, got, tc.want) + } + }) + } +} + +// TestHealthcheck verifies the self-probe maps readiness states to nil/err. +func TestHealthcheck(t *testing.T) { + tests := []struct { + name, desc, class string + status int // status the fake /readyz returns + closed bool // if true, hit a closed server (connection refused) + wantErr bool + }{ + {"positive_ready", "positive: a 200 from /readyz means ready (nil error)", "positive", + http.StatusOK, false, false}, + {"negative_not_ready", "negative: a 503 means not ready (error)", "negative", + http.StatusServiceUnavailable, false, true}, + {"corner_conn_refused", "corner: a closed server (no daemon) is an error", "corner", + 0, true, true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(tc.status) + })) + url := srv.URL + "/readyz" + if tc.closed { + srv.Close() // dial target now refuses connections + } else { + defer srv.Close() + } + err := healthcheck(url, 2*time.Second) + if tc.wantErr && err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + if !tc.wantErr && err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + }) + } +} + +// TestParseFlagsDaemonValidation covers the daemon/interval validation. +func TestParseFlagsDaemonValidation(t *testing.T) { + tests := []struct { + name string + desc string + class string + args []string + wantErr bool + }{ + {"positive_singleshot", "positive: no flags is a valid single-shot config", "positive", + []string{}, false}, + {"positive_daemon", "positive: daemon with a valid interval", "positive", + []string{"-daemon", "-interval", "6h"}, false}, + {"negative_daemon_zero", "negative: daemon with a zero interval is rejected", "negative", + []string{"-daemon", "-interval", "0"}, true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + _, err := parseFlags(tc.args) + if tc.wantErr && err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + if !tc.wantErr && err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + }) + } +} + +// TestParseFlagsOutFile covers the -out-file flag and its IPFEED_OUT_FILE env +// fallback, plus flag-over-env precedence. +func TestParseFlagsOutFile(t *testing.T) { + tests := []struct { + name, desc, class string + env string // IPFEED_OUT_FILE (unset if envSet is false) + envSet bool + args []string + want string + }{ + {"positive_flag", "positive: -out-file sets the exact path", "positive", + "", false, []string{"-out-file", "/data/feeds.parquet"}, "/data/feeds.parquet"}, + {"positive_env", "positive: IPFEED_OUT_FILE is used when the flag is absent", "positive", + "/env/feeds.parquet", true, []string{}, "/env/feeds.parquet"}, + {"corner_flag_over_env", "corner: the flag wins over the env var", "corner", + "/env/feeds.parquet", true, []string{"-out-file", "/flag/feeds.parquet"}, "/flag/feeds.parquet"}, + {"boundary_unset", "boundary: empty by default (dir+timestamp behavior)", "boundary", + "", false, []string{}, ""}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + setOrUnset(t, "IPFEED_OUT_FILE", tc.env, tc.envSet) + f, err := parseFlags(tc.args) + if err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + if f.outFile != tc.want { + t.Errorf("%s: outFile = %q, want %q", tc.desc, f.outFile, tc.want) + } + }) + } +} + +// TestParseFlagsS3Creds covers credential/region resolution across the +// IPFEED_S3_* and standard AWS_* env names, including their precedence. +func TestParseFlagsS3Creds(t *testing.T) { + // field selects which resolved value the case asserts on. + const ( + access = "access" + secret = "secret" + region = "region" + ) + tests := []struct { + name, desc, class string + field string + ipfeed string // IPFEED_S3_* value ("" = unset) + aws string // AWS_* value ("" = unset) + args []string + want string + }{ + {"positive_aws_access", "positive: AWS_ACCESS_KEY_ID is used as a fallback", "positive", + access, "", "AKIA_AWS", nil, "AKIA_AWS"}, + {"corner_ipfeed_over_aws", "corner: IPFEED_S3_ACCESS_KEY wins over AWS_ACCESS_KEY_ID", "corner", + access, "AKIA_IPFEED", "AKIA_AWS", nil, "AKIA_IPFEED"}, + {"corner_flag_over_all", "corner: the flag wins over both env names", "corner", + access, "AKIA_IPFEED", "AKIA_AWS", []string{"-s3-access-key", "AKIA_FLAG"}, "AKIA_FLAG"}, + {"positive_aws_secret", "positive: AWS_SECRET_ACCESS_KEY is used as a fallback", "positive", + secret, "", "sekret_aws", nil, "sekret_aws"}, + {"positive_aws_region", "positive: AWS_REGION is used as a fallback", "positive", + region, "", "eu-west-1", nil, "eu-west-1"}, + {"boundary_region_default", "boundary: region defaults to us-east-1 when nothing is set", "boundary", + region, "", "", nil, "us-east-1"}, + {"corner_ipfeed_region_over_aws", "corner: IPFEED_S3_REGION wins over AWS_REGION", "corner", + region, "ap-south-1", "eu-west-1", nil, "ap-south-1"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + var ipfeedKey, awsKey string + switch tc.field { + case access: + ipfeedKey, awsKey = "IPFEED_S3_ACCESS_KEY", "AWS_ACCESS_KEY_ID" + case secret: + ipfeedKey, awsKey = "IPFEED_S3_SECRET_KEY", "AWS_SECRET_ACCESS_KEY" + case region: + ipfeedKey, awsKey = "IPFEED_S3_REGION", "AWS_REGION" + } + setOrUnset(t, ipfeedKey, tc.ipfeed, tc.ipfeed != "") + setOrUnset(t, awsKey, tc.aws, tc.aws != "") + + f, err := parseFlags(tc.args) + if err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + var got string + switch tc.field { + case access: + got = f.s3.AccessKey + case secret: + got = f.s3.SecretKey + case region: + got = f.s3.Region + } + if got != tc.want { + t.Errorf("%s: %s = %q, want %q", tc.desc, tc.field, got, tc.want) + } + }) + } +} + +// TestRunDaemon verifies the loop runs the immediate cycle plus ticks, marks +// ready only on success, and stops on context cancellation. +func TestRunDaemon(t *testing.T) { + tests := []struct { + name string + desc string + class string + stopAfter int // cancel ctx once collect has been called this many times + failEvery int // return an error on calls where call%failEvery==0 (0 = never) + wantCalls int + wantReady bool + }{ + {"positive_runs_n_cycles", "positive: immediate cycle + ticks until canceled", "positive", + 3, 0, 3, true}, + {"boundary_single_cycle", "boundary: cancel after the first (immediate) cycle", "boundary", + 1, 0, 1, true}, + {"negative_all_fail_not_ready", "negative: if every cycle fails, ready is never set", "negative", + 2, 1, 2, false}, + {"corner_intermittent_failure", "corner: a failing cycle does not stop the loop; a later success sets ready", "corner", + 3, 3, 3, true}, // call 3 fails, but calls 1-2 succeeded -> ready + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + var calls atomic.Int64 + var ready atomic.Bool + collect := func(context.Context) error { + n := int(calls.Add(1)) + var err error + if tc.failEvery > 0 && n%tc.failEvery == 0 { + err = context.DeadlineExceeded // any non-nil error + } + if n >= tc.stopAfter { + cancel() + } + return err + } + readyFn := func() { ready.Store(true) } + + // Tiny interval so ticks fire quickly; correctness does not depend + // on timing because collect cancels the context deterministically. + err := runDaemon(ctx, time.Millisecond, readyFn, collect, discardLogger()) + if err != nil { + t.Fatalf("%s: runDaemon returned error: %v", tc.desc, err) + } + if got := int(calls.Load()); got != tc.wantCalls { + t.Errorf("%s: calls = %d, want %d", tc.desc, got, tc.wantCalls) + } + if ready.Load() != tc.wantReady { + t.Errorf("%s: ready = %v, want %v", tc.desc, ready.Load(), tc.wantReady) + } + }) + } +} diff --git a/cmd/ipfeed-collector/sources/apple-privaterelay.yaml b/cmd/ipfeed-collector/sources/apple-privaterelay.yaml new file mode 100644 index 0000000..fde250d --- /dev/null +++ b/cmd/ipfeed-collector/sources/apple-privaterelay.yaml @@ -0,0 +1,16 @@ +name: apple-privaterelay +provider: apple +url: https://mask-api.icloud.com/egress-ip-ranges.csv +parser: csv +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: apple + service_operator: apple + service: icloud-private-relay + direction: egress +parser_opts: + has_header: false + prefix_column: 0 + region_column: 2 +enabled: true diff --git a/cmd/ipfeed-collector/sources/applebot.yaml b/cmd/ipfeed-collector/sources/applebot.yaml new file mode 100644 index 0000000..4e93f46 --- /dev/null +++ b/cmd/ipfeed-collector/sources/applebot.yaml @@ -0,0 +1,11 @@ +name: applebot +provider: apple +url: https://search.developer.apple.com/applebot.json +parser: applebot +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: apple + service_operator: apple + service: applebot +enabled: true diff --git a/cmd/ipfeed-collector/sources/atlassian.yaml b/cmd/ipfeed-collector/sources/atlassian.yaml new file mode 100644 index 0000000..2332827 --- /dev/null +++ b/cmd/ipfeed-collector/sources/atlassian.yaml @@ -0,0 +1,10 @@ +name: atlassian +provider: atlassian +url: https://ip-ranges.atlassian.com/ +parser: atlassian +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: atlassian + service_operator: atlassian +enabled: true diff --git a/cmd/ipfeed-collector/sources/aws-geo-feed.yaml b/cmd/ipfeed-collector/sources/aws-geo-feed.yaml new file mode 100644 index 0000000..038b2a1 --- /dev/null +++ b/cmd/ipfeed-collector/sources/aws-geo-feed.yaml @@ -0,0 +1,14 @@ +name: aws-geo-feed +provider: aws +url: https://ip-ranges.amazonaws.com/geo-ip-feed.csv +parser: csv +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: aws + service_operator: aws +parser_opts: + has_header: false + prefix_column: 0 + region_column: 1 +enabled: true diff --git a/cmd/ipfeed-collector/sources/aws-ip-ranges.yaml b/cmd/ipfeed-collector/sources/aws-ip-ranges.yaml new file mode 100644 index 0000000..fd50752 --- /dev/null +++ b/cmd/ipfeed-collector/sources/aws-ip-ranges.yaml @@ -0,0 +1,10 @@ +name: aws-ip-ranges +provider: aws +url: https://ip-ranges.amazonaws.com/ip-ranges.json +parser: aws_ip_ranges +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: aws + service_operator: aws +enabled: true diff --git a/cmd/ipfeed-collector/sources/azure-service-tags.yaml b/cmd/ipfeed-collector/sources/azure-service-tags.yaml new file mode 100644 index 0000000..8bdb6e8 --- /dev/null +++ b/cmd/ipfeed-collector/sources/azure-service-tags.yaml @@ -0,0 +1,11 @@ +name: azure-service-tags +provider: azure +url: https://www.microsoft.com/en-us/download/details.aspx?id=56519 +parser: azure_service_tags +source_type: provider_feed +confidence: authoritative +discover: azure_download_page +defaults: + network_owner: microsoft + service_operator: microsoft +enabled: true diff --git a/cmd/ipfeed-collector/sources/cloudflare-v4.yaml b/cmd/ipfeed-collector/sources/cloudflare-v4.yaml new file mode 100644 index 0000000..dddd47a --- /dev/null +++ b/cmd/ipfeed-collector/sources/cloudflare-v4.yaml @@ -0,0 +1,11 @@ +name: cloudflare-v4 +provider: cloudflare +url: https://www.cloudflare.com/ips-v4 +parser: text_cidr +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: cloudflare + service_operator: cloudflare + service: proxy +enabled: true diff --git a/cmd/ipfeed-collector/sources/cloudflare-v6.yaml b/cmd/ipfeed-collector/sources/cloudflare-v6.yaml new file mode 100644 index 0000000..d2a4ca1 --- /dev/null +++ b/cmd/ipfeed-collector/sources/cloudflare-v6.yaml @@ -0,0 +1,11 @@ +name: cloudflare-v6 +provider: cloudflare +url: https://www.cloudflare.com/ips-v6 +parser: text_cidr +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: cloudflare + service_operator: cloudflare + service: proxy +enabled: true diff --git a/cmd/ipfeed-collector/sources/digitalocean.yaml b/cmd/ipfeed-collector/sources/digitalocean.yaml new file mode 100644 index 0000000..205e998 --- /dev/null +++ b/cmd/ipfeed-collector/sources/digitalocean.yaml @@ -0,0 +1,14 @@ +name: digitalocean +provider: digitalocean +url: https://digitalocean.com/geo/google.csv +parser: csv +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: digitalocean + service_operator: digitalocean +parser_opts: + has_header: false + prefix_column: 0 + region_column: 2 +enabled: true diff --git a/cmd/ipfeed-collector/sources/fastly.yaml b/cmd/ipfeed-collector/sources/fastly.yaml new file mode 100644 index 0000000..e2471e2 --- /dev/null +++ b/cmd/ipfeed-collector/sources/fastly.yaml @@ -0,0 +1,10 @@ +name: fastly +provider: fastly +url: https://api.fastly.com/public-ip-list +parser: fastly +source_type: provider_api +confidence: authoritative +defaults: + network_owner: fastly + service_operator: fastly +enabled: true diff --git a/cmd/ipfeed-collector/sources/gcp-cloud.yaml b/cmd/ipfeed-collector/sources/gcp-cloud.yaml new file mode 100644 index 0000000..9223649 --- /dev/null +++ b/cmd/ipfeed-collector/sources/gcp-cloud.yaml @@ -0,0 +1,10 @@ +name: gcp-cloud +provider: gcp +url: https://www.gstatic.com/ipranges/cloud.json +parser: gcp_ipranges +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: google + service_operator: google +enabled: true diff --git a/cmd/ipfeed-collector/sources/gcp-goog.yaml b/cmd/ipfeed-collector/sources/gcp-goog.yaml new file mode 100644 index 0000000..03db53f --- /dev/null +++ b/cmd/ipfeed-collector/sources/gcp-goog.yaml @@ -0,0 +1,10 @@ +name: gcp-goog +provider: gcp +url: https://www.gstatic.com/ipranges/goog.json +parser: gcp_ipranges +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: google + service_operator: google +enabled: true diff --git a/cmd/ipfeed-collector/sources/github-meta.yaml b/cmd/ipfeed-collector/sources/github-meta.yaml new file mode 100644 index 0000000..de28a42 --- /dev/null +++ b/cmd/ipfeed-collector/sources/github-meta.yaml @@ -0,0 +1,10 @@ +name: github-meta +provider: github +url: https://api.github.com/meta +parser: github_meta +source_type: provider_api +confidence: authoritative +defaults: + network_owner: github + service_operator: github +enabled: true diff --git a/cmd/ipfeed-collector/sources/google-common-crawlers.yaml b/cmd/ipfeed-collector/sources/google-common-crawlers.yaml new file mode 100644 index 0000000..c41c237 --- /dev/null +++ b/cmd/ipfeed-collector/sources/google-common-crawlers.yaml @@ -0,0 +1,11 @@ +name: google-common-crawlers +provider: google +url: https://developers.google.com/crawling/ipranges/common-crawlers.json +parser: google_crawlers +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: google + service_operator: google + service: common-crawlers +enabled: true diff --git a/cmd/ipfeed-collector/sources/google-special-crawlers.yaml b/cmd/ipfeed-collector/sources/google-special-crawlers.yaml new file mode 100644 index 0000000..ad68f49 --- /dev/null +++ b/cmd/ipfeed-collector/sources/google-special-crawlers.yaml @@ -0,0 +1,11 @@ +name: google-special-crawlers +provider: google +url: https://developers.google.com/crawling/ipranges/special-crawlers.json +parser: google_crawlers +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: google + service_operator: google + service: special-crawlers +enabled: true diff --git a/cmd/ipfeed-collector/sources/google-user-triggered-fetchers.yaml b/cmd/ipfeed-collector/sources/google-user-triggered-fetchers.yaml new file mode 100644 index 0000000..b4875c6 --- /dev/null +++ b/cmd/ipfeed-collector/sources/google-user-triggered-fetchers.yaml @@ -0,0 +1,11 @@ +name: google-user-triggered-fetchers +provider: google +url: https://developers.google.com/crawling/ipranges/user-triggered-fetchers.json +parser: google_crawlers +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: google + service_operator: google + service: user-triggered-fetchers +enabled: true diff --git a/cmd/ipfeed-collector/sources/m365-worldwide.yaml b/cmd/ipfeed-collector/sources/m365-worldwide.yaml new file mode 100644 index 0000000..596ad85 --- /dev/null +++ b/cmd/ipfeed-collector/sources/m365-worldwide.yaml @@ -0,0 +1,11 @@ +name: m365-worldwide +provider: microsoft +url: https://endpoints.office.com/endpoints/worldwide?clientrequestid=00000000-0000-0000-0000-000000000000 +parser: m365 +source_type: provider_api +confidence: authoritative +defaults: + network_owner: microsoft + service_operator: microsoft + product: microsoft-365 +enabled: true diff --git a/cmd/ipfeed-collector/sources/oci.yaml b/cmd/ipfeed-collector/sources/oci.yaml new file mode 100644 index 0000000..92c5bcf --- /dev/null +++ b/cmd/ipfeed-collector/sources/oci.yaml @@ -0,0 +1,10 @@ +name: oci +provider: oracle +url: https://docs.oracle.com/iaas/tools/public_ip_ranges.json +parser: oci +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: oracle + service_operator: oracle +enabled: true diff --git a/cmd/ipfeed-collector/sources/salesforce.yaml b/cmd/ipfeed-collector/sources/salesforce.yaml new file mode 100644 index 0000000..787a2f2 --- /dev/null +++ b/cmd/ipfeed-collector/sources/salesforce.yaml @@ -0,0 +1,11 @@ +name: salesforce +provider: salesforce +url: https://ip-ranges.salesforce.com/ip-ranges.json +parser: salesforce +source_type: provider_feed +confidence: authoritative +defaults: + network_owner: salesforce + service_operator: salesforce + service: hyperforce +enabled: true diff --git a/docs/ipfeed-asn-enrichment.md b/docs/ipfeed-asn-enrichment.md new file mode 100644 index 0000000..b3620b5 --- /dev/null +++ b/docs/ipfeed-asn-enrichment.md @@ -0,0 +1,117 @@ +# IP → ASN / network-owner enrichment + +## Context and goal + +`ipfeed-collector` (`cmd/ipfeed-collector`) fetches public cloud / CDN / SaaS +IP-range feeds (AWS, GCP, Azure, Cloudflare, Fastly, …), normalizes them to one +schema, and writes a combined Parquet artifact (optionally to S3). Each row is +essentially `prefix → {network_owner, provider, service, region, …}`. + +xtcp2 builds one `XtcpFlatRecord` per TCP socket on a hot path. Two of its +fields were reserved but never populated: + +- `inet_diag_msg_socket_dest_asn` (1011) +- `inet_diag_msg_socket_next_hop_asn` (1012) + +This work populates the **destination** side per socket, from the feed data we +already parse: + +- **`inet_diag_msg_socket_dest_asn` (1011)** — a *representative* ASN derived + from the destination's network owner via a small curated `provider → ASN` + map (`internal/ipfeed/asnmap`). +- **`inet_diag_msg_socket_dest_network_owner` (1018, new)** — the feed's + `network_owner` string verbatim (e.g. `cloudflare`, `aws`). No ASN + indirection, so it is exact for any prefix the feeds cover. + +`next_hop_asn` (1012) stays 0 — see *Phasing*. + +### Data reality and the representative-ASN caveat + +The feeds identify the **owner** of a prefix, not its BGP-origin ASN. We bridge +that gap with a curated name→ASN table. This is deliberately **lossy**: large +providers announce prefixes from several ASNs (AWS also uses AS14618/AS8987; +Google also AS36040/AS36384), so a single name→ASN mapping yields a +*representative* origin ASN, not per-prefix truth. `dest_network_owner` has no +such caveat — it is the feed value directly. True per-prefix origin (and +next-hop) ASN requires a BGP RIB (MRT) source; that is a later phase. + +## Where enrichment runs + +**On-agent (chosen).** The ASN and network-owner must live *in the record* as it +is written, so any downstream consumer (Parquet on S3, ClickHouse, Kafka) sees +them without a join. The alternative — enrich downstream in a batch SQL job — +keeps the agent simpler but leaves the live record incomplete and forces every +consumer to carry the range-join. Since the fields already exist in the schema +and the lookup is cheap (see below), on-agent enrichment wins. + +## Lookup-structure options + +The per-socket path is allocation-, syscall-, and lock-free by contract (see +`pkg/xtcp/enrich.go`). The lookup structure must not violate that. + +| Option | Pros | Cons | Verdict | +|---|---|---|---| +| **In-proc LPM trie** (`github.com/gaissmai/bart`) | ns-scale lookups; pure Go (`CGO_ENABLED=0`); no syscalls; table swapped atomically for refresh; alloc/lock-free reads | table held in RAM; built on load | **Recommended** — measured 12.7 ns/op, 0 allocs; fits the hot-path contract exactly | +| **MMDB + mmap** (`oschwald/maxminddb-golang`) | industry-standard IP→data format; mmap keeps RSS low; refresh = swap file; tiny load time | adds a writer dependency + format overhead; another artifact format to produce | Strong alternative / future *distribution* format | +| **Linux routing table** (netlink FIB) | reuses the kernel's LPM | a syscall per record (kills the hot-path contract); needs `CAP_NET_ADMIN`; ~1M routes to install/maintain; no clean place for an ASN/owner payload | Rejected for the hot path | +| **duckdb / sqlite range-join** (downstream) | zero agent cost; full SQL flexibility | ASN/owner absent from the live record; per-query latency; consumers must all carry the join | Alternative for *batch* enrichment only | + +**Recommendation: in-process LPM trie (`gaissmai/bart`).** It is the only option +that keeps the per-socket path alloc/lock/syscall-free while allowing a +background refresh. MMDB is noted as a likely future *distribution* format if we +ever ship the artifact to third parties. + +## Architecture + +Producer / consumer, mirroring the existing `pkg/dockermeta` and `pkg/cgroupid` +enrichers: + +- **Producer** — `ipfeed-collector`. `internal/ipfeed/asnmap` annotates each + parsed record with its representative ASN; the Parquet artifact now carries + `prefix → {asn, network_owner, provider, …}`. +- **Consumer** — `pkg/ipasn`. `New(path)` loads the artifact into a + `bart.Table[Attr]` behind an `atomic.Pointer`; `Lookup(netip.Addr) (Attr, bool)` + is a pure longest-prefix read; `Reload(path)` rebuilds and swaps the pointer, + so a refresh never blocks readers and a *failed* reload leaves the in-service + table intact. + +### Hot-path wiring (`pkg/xtcp`) + +- `initAsnEnricher` (`enrich.go`) loads `asn_db_path` once at startup, gated by + `enrich_asn_enable`. If `asn_refresh_interval > 0`, a background goroutine + reloads on that cadence (bound to the daemon context). Every failure is + best-effort: log + Prometheus counter, columns left empty, never fatal. +- `applyEnrichment` converts the record's 16-byte destination + (`inet_diag_msg_socket_destination`, a kernel `__be32[4]` slot) to a + `netip.Addr` **alloc-free**, keyed on `inet_diag_msg_family` (IPv4 lives in the + first 4 bytes, so family is authoritative — see `destAddr`), then + `asnIndex.Lookup` sets `dest_asn` and `dest_network_owner`. No-op when the + enricher is disabled or the index is nil. + +### Configuration (`proto/xtcp_config/v1`) + +- `enrich_asn_enable` (bool, 239) +- `asn_db_path` (string, 240) +- `asn_refresh_interval` (Duration, 241; 0 = load once, never reload) + +## Artifact format + +Phase 1 reuses the collector's existing **Parquet** artifact — `pkg/ipasn` reads +only the `prefix`, `asn`, and `network_owner` columns. MMDB is noted above as a +possible future distribution format. + +## Phasing + +- **Phase 1 (this work).** `provider → ASN` map over the existing feeds fills + `dest_asn` (representative) and `dest_network_owner` (exact). In-proc `bart` + trie; on-agent; opt-in. +- **Phase 2 (future).** Ingest a BGP RIB (MRT) so we can attach the *real* + per-prefix origin ASN and populate `next_hop_asn` (1012). The `pkg/ipasn` + interface (`Attr` + LPM `Lookup`) is designed to absorb this without changing + the hot-path wiring. + +## Out of scope + +- BGP RIB / MRT ingestion and `next_hop_asn` (1012). +- Enriching the *source* ASN (destination only in phase 1). +- Pushing the collector OCI image to a registry / release pipeline. diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc index 7e3391f..32dbd37 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc @@ -1515,12 +1515,12 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const { PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_._has_bits_), 0, // no _extensions_ - 238, 248, // max_field_number, fast_idx_mask + 241, 248, // max_field_number, fast_idx_mask offsetof(ParseTableT_, field_lookup_table), 3757571583, // skipmap offsetof(ParseTableT_, field_entries), - 66, // num_field_entries - 7, // num_aux_entries + 69, // num_field_entries + 8, // num_aux_entries offsetof(ParseTableT_, aux_entries), class_data, nullptr, // post_loop_handler @@ -1626,7 +1626,7 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const 65464, 40, 58366, 44, 8207, 48, - 65408, 59, + 64512, 59, 65535, 65535 }}, {{ // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { @@ -1652,11 +1652,11 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.capture_path_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.marshal_to_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 43, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_rows_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { @@ -1674,11 +1674,11 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string dest = 130 [json_name = "dest", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_), _Internal::kHasBitsOffset + 23, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_region_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { @@ -1686,9 +1686,9 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_app_name_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string topic = 140 [json_name = "topic", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.topic_), _Internal::kHasBitsOffset + 25, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { @@ -1696,9 +1696,9 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_schema_url_), _Internal::kHasBitsOffset + 27, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_), _Internal::kHasBitsOffset + 37, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_), _Internal::kHasBitsOffset + 38, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string label = 170 [json_name = "label", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.label_), _Internal::kHasBitsOffset + 28, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string tag = 180 [json_name = "tag", (.buf.validate.field) = { @@ -1708,59 +1708,65 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.hostname_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.daemon_version_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_), _Internal::kHasBitsOffset + 38, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_), _Internal::kHasBitsOffset + 39, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.csv_columns_), _Internal::kHasBitsOffset + 33, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_interval_), _Internal::kHasBitsOffset + 39, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_interval_), _Internal::kHasBitsOffset + 40, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_backoff_cap_), _Internal::kHasBitsOffset + 40, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_backoff_cap_), _Internal::kHasBitsOffset + 41, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_), _Internal::kHasBitsOffset + 41, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_), _Internal::kHasBitsOffset + 42, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_container_enable_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_container_enable_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.docker_socket_path_), _Internal::kHasBitsOffset + 34, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_lldp_enable_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_lldp_enable_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_socket_path_), _Internal::kHasBitsOffset + 35, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_version_hint_), _Internal::kHasBitsOffset + 36, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_nic_enable_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_nic_enable_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_interfaces_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, // bool populate_nsid = 238 [json_name = "populateNsid"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_db_path_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_refresh_interval_), _Internal::kHasBitsOffset + 43, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ #ifndef PROTOBUF_MESSAGE_GLOBALS @@ -1798,9 +1804,14 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const #else {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, #endif + #ifndef PROTOBUF_MESSAGE_GLOBALS + {::_pbi::TcParser::GetTable<::google::protobuf::Duration>()}, + #else + {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, + #endif }}, {{ - "\31\0\0\0\0\0\0\0\0\0\0\14\0\12\0\0\21\13\11\11\15\15\4\0\11\0\0\15\22\0\0\5\17\20\0\0\5\3\10\10\0\0\0\16\0\0\0\0\0\13\0\0\0\0\0\0\0\0\0\22\0\21\22\0\0\21\0\0\0\0\0\0" + "\31\0\0\0\0\0\0\0\0\0\0\14\0\12\0\0\21\13\11\11\15\15\4\0\11\0\0\15\22\0\0\5\17\20\0\0\5\3\10\10\0\0\0\16\0\0\0\0\0\13\0\0\0\0\0\0\0\0\0\22\0\21\22\0\0\21\0\0\13\0\0\0" "xtcp_config.v1.XtcpConfig" "capture_path" "marshal_to" @@ -1827,6 +1838,7 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const "lldpd_socket_path" "lldpd_version_hint" "uplink_interfaces" + "asn_db_path" }}, }; } @@ -1925,11 +1937,15 @@ inline constexpr XtcpConfig::Impl_::Impl_( lldpd_version_hint_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), + asn_db_path_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), kafka_produce_timeout_{nullptr}, enabled_deserializers_{nullptr}, s3_flush_interval_{nullptr}, s3_upload_backoff_cap_{nullptr}, reconcile_frequency_{nullptr}, + asn_refresh_interval_{nullptr}, modulus_{::uint64_t{0u}}, envelope_flush_threshold_bytes_{0u}, s3_parquet_flush_threshold_bytes_{0u}, @@ -1953,7 +1969,8 @@ inline constexpr XtcpConfig::Impl_::Impl_( enrich_lldp_enable_{false}, enrich_nic_enable_{false}, populate_nsid_{false}, - uplink_count_{0u} {} + uplink_count_{0u}, + enrich_asn_enable_{false} {} template constexpr XtcpConfig::XtcpConfig(::_pbi::ConstantInitialized, @@ -3008,7 +3025,7 @@ const ::uint32_t 0, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_._has_bits_), - 69, // hasbit index offset + 72, // hasbit index offset PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.nl_timeout_milliseconds_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_frequency_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_timeout_), @@ -3075,6 +3092,9 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.uplink_count_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.uplink_interfaces_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.populate_nsid_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_asn_enable_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.asn_db_path_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.asn_refresh_interval_), 7, 5, 6, @@ -3086,9 +3106,9 @@ const ::uint32_t 13, 14, 18, - 42, + 44, 19, - 43, + 45, 15, 20, 0, @@ -3096,51 +3116,54 @@ const ::uint32_t 1, 22, 2, - 44, + 46, 3, - 50, + 52, 24, 4, - 45, - 46, + 47, + 48, 23, 16, 25, 26, 27, - 37, - 47, + 38, + 49, 28, 29, 30, 31, 32, + 53, + 50, 51, - 48, - 49, - 54, - 38, - 52, - 55, 56, - 33, - 57, 39, + 54, + 57, 58, + 33, 59, - 60, 40, - 41, - 53, + 60, 61, - 34, 62, + 41, + 42, + 55, + 63, + 34, + 64, 35, 36, - 63, 65, + 67, 17, - 64, + 66, + 68, + 37, + 43, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse, _impl_._has_bits_), 5, // hasbit index offset @@ -3172,8 +3195,8 @@ static const ::_pbi::MigrationSchema {56, sizeof(::xtcp_config::v1::SetEnvelopeFlushRequest)}, {63, sizeof(::xtcp_config::v1::SetEnvelopeFlushResponse)}, {68, sizeof(::xtcp_config::v1::XtcpConfig)}, - {203, sizeof(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse)}, - {210, sizeof(::xtcp_config::v1::EnabledDeserializers)}, + {209, sizeof(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse)}, + {216, sizeof(::xtcp_config::v1::EnabledDeserializers)}, }; static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const file_message_globals[] = { @@ -3245,7 +3268,7 @@ const char descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto[ " 0 || this.envelope_flush_threshold_rows" " > 0\"N\n\030SetEnvelopeFlushResponse\0222\n\006conf" "ig\030\001 \001(\0132\032.xtcp_config.v1.XtcpConfigR\006co" - "nfig\"\371\035\n\nXtcpConfig\022F\n\027nl_timeout_millis" + "nfig\"\237\037\n\nXtcpConfig\022F\n\027nl_timeout_millis" "econds\030\n \001(\004B\016\272H\0132\006\030\240\215\006(\000\310\001\001R\025nlTimeoutM" "illiseconds\022S\n\016poll_frequency\030\024 \001(\0132\031.go" "ogle.protobuf.DurationB\021\272H\016\252\001\010\"\004\010\200\365$*\000\310\001" @@ -3338,40 +3361,44 @@ const char descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto[ "\030\354\001 \001(\rB\007\272H\004*\002\030\002R\013uplinkCount\0226\n\021uplink_" "interfaces\030\355\001 \003(\tB\010\272H\005\222\001\002\020\002R\020uplinkInter" "faces\022$\n\rpopulate_nsid\030\356\001 \001(\010R\014populateN" - "sid:s\272Hp\032n\n\017XtcpConfig.poll\0222Poll timeou" - "t must be less than poll poll_frequency\032" - "\'this.poll_frequency > this.poll_timeout" - "\"\237\001\n\024EnabledDeserializers\022K\n\007enabled\030\001 \003" - "(\01321.xtcp_config.v1.EnabledDeserializers" - ".EnabledEntryR\007enabled\032:\n\014EnabledEntry\022\020" - "\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\010R\005value:\002" - "8\0012\207\007\n\rConfigService\022]\n\003Get\022\032.xtcp_confi" - "g.v1.GetRequest\032\033.xtcp_config.v1.GetResp" - "onse\"\035\202\323\344\223\002\027\032\022/ConfigService/Get:\001*\022]\n\003S" - "et\022\032.xtcp_config.v1.SetRequest\032\033.xtcp_co" - "nfig.v1.SetResponse\"\035\202\323\344\223\002\027\032\022/ConfigServ" - "ice/Set:\001*\022\221\001\n\020SetPollFrequency\022\'.xtcp_c" - "onfig.v1.SetPollFrequencyRequest\032(.xtcp_" - "config.v1.SetPollFrequencyResponse\"*\202\323\344\223" - "\002$\032\037/ConfigService/SetPollFrequency:\001*\022}" - "\n\013TriggerPoll\022\".xtcp_config.v1.TriggerPo" - "llRequest\032#.xtcp_config.v1.TriggerPollRe" - "sponse\"%\202\323\344\223\002\037\032\032/ConfigService/TriggerPo" - "ll:\001*\022\221\001\n\020TriggerPollBurst\022\'.xtcp_config" - ".v1.TriggerPollBurstRequest\032(.xtcp_confi" - "g.v1.TriggerPollBurstResponse\"*\202\323\344\223\002$\032\037/" - "ConfigService/TriggerPollBurst:\001*\022}\n\013Set" - "S3Upload\022\".xtcp_config.v1.SetS3UploadReq" - "uest\032#.xtcp_config.v1.SetS3UploadRespons" - "e\"%\202\323\344\223\002\037\032\032/ConfigService/SetS3Upload:\001*" - "\022\221\001\n\020SetEnvelopeFlush\022\'.xtcp_config.v1.S" - "etEnvelopeFlushRequest\032(.xtcp_config.v1." - "SetEnvelopeFlushResponse\"*\202\323\344\223\002$\032\037/Confi" - "gService/SetEnvelopeFlush:\001*B\220\001\n\022com.xtc" - "p_config.v1B\017XtcpConfigProtoP\001Z\024./gen/go" - "/xtcp_config\242\002\003XXX\252\002\rXtcpConfig.V1\312\002\rXtc" - "pConfig\\V1\342\002\031XtcpConfig\\V1\\GPBMetadata\352\002" - "\016XtcpConfig::V1b\006proto3" + "sid\022+\n\021enrich_asn_enable\030\357\001 \001(\010R\017enrichA" + "snEnable\022)\n\013asn_db_path\030\360\001 \001(\tB\010\272H\005r\003\030\377\001" + "R\tasnDbPath\022L\n\024asn_refresh_interval\030\361\001 \001" + "(\0132\031.google.protobuf.DurationR\022asnRefres" + "hInterval:s\272Hp\032n\n\017XtcpConfig.poll\0222Poll " + "timeout must be less than poll poll_freq" + "uency\032\'this.poll_frequency > this.poll_t" + "imeout\"\237\001\n\024EnabledDeserializers\022K\n\007enabl" + "ed\030\001 \003(\01321.xtcp_config.v1.EnabledDeseria" + "lizers.EnabledEntryR\007enabled\032:\n\014EnabledE" + "ntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\010R\005v" + "alue:\0028\0012\207\007\n\rConfigService\022]\n\003Get\022\032.xtcp" + "_config.v1.GetRequest\032\033.xtcp_config.v1.G" + "etResponse\"\035\202\323\344\223\002\027\032\022/ConfigService/Get:\001" + "*\022]\n\003Set\022\032.xtcp_config.v1.SetRequest\032\033.x" + "tcp_config.v1.SetResponse\"\035\202\323\344\223\002\027\032\022/Conf" + "igService/Set:\001*\022\221\001\n\020SetPollFrequency\022\'." + "xtcp_config.v1.SetPollFrequencyRequest\032(" + ".xtcp_config.v1.SetPollFrequencyResponse" + "\"*\202\323\344\223\002$\032\037/ConfigService/SetPollFrequenc" + "y:\001*\022}\n\013TriggerPoll\022\".xtcp_config.v1.Tri" + "ggerPollRequest\032#.xtcp_config.v1.Trigger" + "PollResponse\"%\202\323\344\223\002\037\032\032/ConfigService/Tri" + "ggerPoll:\001*\022\221\001\n\020TriggerPollBurst\022\'.xtcp_" + "config.v1.TriggerPollBurstRequest\032(.xtcp" + "_config.v1.TriggerPollBurstResponse\"*\202\323\344" + "\223\002$\032\037/ConfigService/TriggerPollBurst:\001*\022" + "}\n\013SetS3Upload\022\".xtcp_config.v1.SetS3Upl" + "oadRequest\032#.xtcp_config.v1.SetS3UploadR" + "esponse\"%\202\323\344\223\002\037\032\032/ConfigService/SetS3Upl" + "oad:\001*\022\221\001\n\020SetEnvelopeFlush\022\'.xtcp_confi" + "g.v1.SetEnvelopeFlushRequest\032(.xtcp_conf" + "ig.v1.SetEnvelopeFlushResponse\"*\202\323\344\223\002$\032\037" + "/ConfigService/SetEnvelopeFlush:\001*B\220\001\n\022c" + "om.xtcp_config.v1B\017XtcpConfigProtoP\001Z\024./" + "gen/go/xtcp_config\242\002\003XXX\252\002\rXtcpConfig.V1" + "\312\002\rXtcpConfig\\V1\342\002\031XtcpConfig\\V1\\GPBMeta" + "data\352\002\016XtcpConfig::V1b\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_deps[3] = { @@ -3383,7 +3410,7 @@ static ::absl::once_flag descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2ep PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto = { false, false, - 6983, + 7149, descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto, "xtcp_config/v1/xtcp_config.proto", &descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_once, @@ -6116,22 +6143,27 @@ void XtcpConfig::clear_poll_timeout() { void XtcpConfig::clear_kafka_produce_timeout() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.kafka_produce_timeout_ != nullptr) _impl_.kafka_produce_timeout_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } void XtcpConfig::clear_s3_flush_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.s3_flush_interval_ != nullptr) _impl_.s3_flush_interval_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); } void XtcpConfig::clear_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.s3_upload_backoff_cap_ != nullptr) _impl_.s3_upload_backoff_cap_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } void XtcpConfig::clear_reconcile_frequency() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.reconcile_frequency_ != nullptr) _impl_.reconcile_frequency_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); +} +void XtcpConfig::clear_asn_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.asn_refresh_interval_ != nullptr) _impl_.asn_refresh_interval_->Clear(); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } XtcpConfig::XtcpConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) @@ -6178,7 +6210,8 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( csv_columns_(arena, from.csv_columns_), docker_socket_path_(arena, from.docker_socket_path_), lldpd_socket_path_(arena, from.lldpd_socket_path_), - lldpd_version_hint_(arena, from.lldpd_version_hint_) {} + lldpd_version_hint_(arena, from.lldpd_version_hint_), + asn_db_path_(arena, from.asn_db_path_) {} XtcpConfig::XtcpConfig( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, @@ -6209,28 +6242,31 @@ XtcpConfig::XtcpConfig( offsetof(Impl_, nl_timeout_milliseconds_) + sizeof(Impl_::dest_write_files_)); cached_has_bits = _impl_._has_bits_[1]; - _impl_.kafka_produce_timeout_ = (CheckHasBit(cached_has_bits, 0x00000020U)) + _impl_.kafka_produce_timeout_ = (CheckHasBit(cached_has_bits, 0x00000040U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kafka_produce_timeout_) : nullptr; - _impl_.enabled_deserializers_ = (CheckHasBit(cached_has_bits, 0x00000040U)) + _impl_.enabled_deserializers_ = (CheckHasBit(cached_has_bits, 0x00000080U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_) : nullptr; - _impl_.s3_flush_interval_ = (CheckHasBit(cached_has_bits, 0x00000080U)) + _impl_.s3_flush_interval_ = (CheckHasBit(cached_has_bits, 0x00000100U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_flush_interval_) : nullptr; - _impl_.s3_upload_backoff_cap_ = (CheckHasBit(cached_has_bits, 0x00000100U)) + _impl_.s3_upload_backoff_cap_ = (CheckHasBit(cached_has_bits, 0x00000200U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_upload_backoff_cap_) : nullptr; - _impl_.reconcile_frequency_ = (CheckHasBit(cached_has_bits, 0x00000200U)) + _impl_.reconcile_frequency_ = (CheckHasBit(cached_has_bits, 0x00000400U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_) : nullptr; + _impl_.asn_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00000800U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.asn_refresh_interval_) + : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, modulus_), reinterpret_cast(&from._impl_) + offsetof(Impl_, modulus_), - offsetof(Impl_, uplink_count_) - + offsetof(Impl_, enrich_asn_enable_) - offsetof(Impl_, modulus_) + - sizeof(Impl_::uplink_count_)); + sizeof(Impl_::enrich_asn_enable_)); // @@protoc_insertion_point(copy_constructor:xtcp_config.v1.XtcpConfig) } @@ -6266,7 +6302,8 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( csv_columns_(arena), docker_socket_path_(arena), lldpd_socket_path_(arena), - lldpd_version_hint_(arena) {} + lldpd_version_hint_(arena), + asn_db_path_(arena) {} inline void XtcpConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); @@ -6279,9 +6316,9 @@ inline void XtcpConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, kafka_produce_timeout_), 0, - offsetof(Impl_, uplink_count_) - + offsetof(Impl_, enrich_asn_enable_) - offsetof(Impl_, kafka_produce_timeout_) + - sizeof(Impl_::uplink_count_)); + sizeof(Impl_::enrich_asn_enable_)); } XtcpConfig::~XtcpConfig() { // @@protoc_insertion_point(destructor:xtcp_config.v1.XtcpConfig) @@ -6320,11 +6357,13 @@ inline void XtcpConfig::SharedDtor(MessageLite& self) { this_._impl_.docker_socket_path_.Destroy(); this_._impl_.lldpd_socket_path_.Destroy(); this_._impl_.lldpd_version_hint_.Destroy(); + this_._impl_.asn_db_path_.Destroy(); delete this_._impl_.kafka_produce_timeout_; delete this_._impl_.enabled_deserializers_; delete this_._impl_.s3_flush_interval_; delete this_._impl_.s3_upload_backoff_cap_; delete this_._impl_.reconcile_frequency_; + delete this_._impl_.asn_refresh_interval_; this_._impl_.~Impl_(); } @@ -6461,48 +6500,55 @@ PROTOBUF_NOINLINE void XtcpConfig::Clear() { _impl_.lldpd_version_hint_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000020U)) { + _impl_.asn_db_path_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000040U)) { ABSL_DCHECK(_impl_.kafka_produce_timeout_ != nullptr); _impl_.kafka_produce_timeout_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { ABSL_DCHECK(_impl_.enabled_deserializers_ != nullptr); _impl_.enabled_deserializers_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { ABSL_DCHECK(_impl_.s3_flush_interval_ != nullptr); _impl_.s3_flush_interval_->Clear(); } - } - if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { ABSL_DCHECK(_impl_.s3_upload_backoff_cap_ != nullptr); _impl_.s3_upload_backoff_cap_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { ABSL_DCHECK(_impl_.reconcile_frequency_ != nullptr); _impl_.reconcile_frequency_->Clear(); } + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + ABSL_DCHECK(_impl_.asn_refresh_interval_ != nullptr); + _impl_.asn_refresh_interval_->Clear(); + } } - if (BatchCheckHasBit(cached_has_bits, 0x0000fc00U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000f000U)) { ::memset(&_impl_.modulus_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.debug_level_) - - reinterpret_cast(&_impl_.modulus_)) + sizeof(_impl_.debug_level_)); + reinterpret_cast(&_impl_.pyroscope_sample_hz_) - + reinterpret_cast(&_impl_.modulus_)) + sizeof(_impl_.pyroscope_sample_hz_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.ipv4_ttl_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.io_uring_recv_batch_size_) - - reinterpret_cast(&_impl_.ipv4_ttl_)) + sizeof(_impl_.io_uring_recv_batch_size_)); + ::memset(&_impl_.pyroscope_upload_interval_sec_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.reconcile_before_poll_) - + reinterpret_cast(&_impl_.pyroscope_upload_interval_sec_)) + sizeof(_impl_.reconcile_before_poll_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.io_uring_cqe_batch_size_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.enrich_nic_enable_) - - reinterpret_cast(&_impl_.io_uring_cqe_batch_size_)) + sizeof(_impl_.enrich_nic_enable_)); + ::memset(&_impl_.grpc_port_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.enrich_container_enable_) - + reinterpret_cast(&_impl_.grpc_port_)) + sizeof(_impl_.enrich_container_enable_)); } cached_has_bits = _impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - ::memset(&_impl_.populate_nsid_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.uplink_count_) - - reinterpret_cast(&_impl_.populate_nsid_)) + sizeof(_impl_.uplink_count_)); + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + ::memset(&_impl_.enrich_lldp_enable_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.enrich_asn_enable_) - + reinterpret_cast(&_impl_.enrich_lldp_enable_)) + sizeof(_impl_.enrich_asn_enable_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); @@ -6625,7 +6671,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_modulus() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -6646,7 +6692,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_envelope_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6736,7 +6782,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6757,7 +6803,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_s3_skip_bucket_probe() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -6797,7 +6843,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_pyroscope_sample_hz() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6806,7 +6852,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_pyroscope_upload_interval_sec() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6847,14 +6893,14 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 150, *this_._impl_.kafka_produce_timeout_, this_._impl_.kafka_produce_timeout_->GetCachedSize(), target, stream); } // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_debug_level() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6905,7 +6951,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_resolve_container_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -6914,7 +6960,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_ipv4_ttl() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6923,7 +6969,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_ipv6_hop_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6942,7 +6988,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_grpc_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6951,14 +6997,14 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 200, *this_._impl_.enabled_deserializers_, this_._impl_.enabled_deserializers_->GetCachedSize(), target, stream); } // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_io_uring() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -6967,7 +7013,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_io_uring_recv_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6976,7 +7022,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_io_uring_cqe_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6995,7 +7041,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_poll_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7004,14 +7050,14 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 222, *this_._impl_.s3_flush_interval_, this_._impl_.s3_flush_interval_->GetCachedSize(), target, stream); } // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_s3_flush_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7020,7 +7066,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7029,7 +7075,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_s3_upload_max_attempts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7038,21 +7084,21 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 226, *this_._impl_.s3_upload_backoff_cap_, this_._impl_.s3_upload_backoff_cap_->GetCachedSize(), target, stream); } // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( 227, *this_._impl_.reconcile_frequency_, this_._impl_.reconcile_frequency_->GetCachedSize(), target, stream); } // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_reconcile_before_poll() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7061,7 +7107,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_enrich_container_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7079,8 +7125,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_lldp_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7088,6 +7135,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[1]; // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (!this_._internal_lldpd_socket_path().empty()) { @@ -7108,8 +7156,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_nic_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7117,9 +7166,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[2]; // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_uplink_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7140,7 +7188,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[2]; // bool populate_nsid = 238 [json_name = "populateNsid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_populate_nsid() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7148,6 +7196,33 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_enrich_asn_enable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 239, this_._internal_enrich_asn_enable(), target); + } + } + + cached_has_bits = this_._impl_._has_bits_[1]; + // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (!this_._internal_asn_db_path().empty()) { + const ::std::string& _s = this_._internal_asn_db_path(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.asn_db_path"); + target = stream->WriteStringMaybeAliased(240, _s, target); + } + } + + // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 241, *this_._impl_.asn_refresh_interval_, this_._impl_.asn_refresh_interval_->GetCachedSize(), target, + stream); + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -7440,200 +7515,218 @@ ::size_t XtcpConfig::ByteSizeLong() const { this_._internal_lldpd_version_hint()); } } - // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (!this_._internal_asn_db_path().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_asn_db_path()); + } + } + // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kafka_produce_timeout_); } // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.enabled_deserializers_); } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_flush_interval_); } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_upload_backoff_cap_); } // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.reconcile_frequency_); } + // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.asn_refresh_interval_); + } // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_modulus() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_modulus()); } } // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_envelope_flush_threshold_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_envelope_flush_threshold_bytes()); } } // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_parquet_flush_threshold_bytes()); } } // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_pyroscope_sample_hz() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_pyroscope_sample_hz()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_pyroscope_upload_interval_sec() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_pyroscope_upload_interval_sec()); } } // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_debug_level() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_debug_level()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_ipv4_ttl() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_ipv4_ttl()); } } // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_ipv6_hop_limit() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_ipv6_hop_limit()); } } // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_s3_skip_bucket_probe() != 0) { total_size += 3; } } // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_resolve_container_id() != 0) { total_size += 3; } } // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_io_uring() != 0) { total_size += 3; } } // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_reconcile_before_poll() != 0) { total_size += 3; } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_grpc_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_grpc_port()); } } // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_io_uring_recv_batch_size() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_io_uring_recv_batch_size()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_io_uring_cqe_batch_size() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_io_uring_cqe_batch_size()); } } // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_poll_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_poll_jitter_pct()); } } // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_s3_flush_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_flush_jitter_pct()); } } // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_flush_threshold_jitter_pct()); } } // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_s3_upload_max_attempts() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_upload_max_attempts()); } } // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_enrich_container_enable() != 0) { total_size += 3; } } + } + cached_has_bits = this_._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_lldp_enable() != 0) { total_size += 3; } } // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_nic_enable() != 0) { total_size += 3; } } - } - cached_has_bits = this_._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { // bool populate_nsid = 238 [json_name = "populateNsid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_populate_nsid() != 0) { total_size += 3; } } // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_uplink_count() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink_count()); } } + // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_enrich_asn_enable() != 0) { + total_size += 3; + } + } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); @@ -7951,6 +8044,15 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (!from._internal_asn_db_path().empty()) { + _this->_internal_set_asn_db_path(from._internal_asn_db_path()); + } else { + if (_this->_impl_.asn_db_path_.IsDefault()) { + _this->_internal_set_asn_db_path(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000040U)) { ABSL_DCHECK(from._impl_.kafka_produce_timeout_ != nullptr); if (_this->_impl_.kafka_produce_timeout_ == nullptr) { _this->_impl_.kafka_produce_timeout_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kafka_produce_timeout_); @@ -7958,7 +8060,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.kafka_produce_timeout_->MergeFrom(*from._impl_.kafka_produce_timeout_); } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { ABSL_DCHECK(from._impl_.enabled_deserializers_ != nullptr); if (_this->_impl_.enabled_deserializers_ == nullptr) { _this->_impl_.enabled_deserializers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_); @@ -7966,7 +8068,9 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.enabled_deserializers_->MergeFrom(*from._impl_.enabled_deserializers_); } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { ABSL_DCHECK(from._impl_.s3_flush_interval_ != nullptr); if (_this->_impl_.s3_flush_interval_ == nullptr) { _this->_impl_.s3_flush_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_flush_interval_); @@ -7974,9 +8078,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.s3_flush_interval_->MergeFrom(*from._impl_.s3_flush_interval_); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { ABSL_DCHECK(from._impl_.s3_upload_backoff_cap_ != nullptr); if (_this->_impl_.s3_upload_backoff_cap_ == nullptr) { _this->_impl_.s3_upload_backoff_cap_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_upload_backoff_cap_); @@ -7984,7 +8086,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.s3_upload_backoff_cap_->MergeFrom(*from._impl_.s3_upload_backoff_cap_); } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { ABSL_DCHECK(from._impl_.reconcile_frequency_ != nullptr); if (_this->_impl_.reconcile_frequency_ == nullptr) { _this->_impl_.reconcile_frequency_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_); @@ -7992,133 +8094,146 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.reconcile_frequency_->MergeFrom(*from._impl_.reconcile_frequency_); } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + ABSL_DCHECK(from._impl_.asn_refresh_interval_ != nullptr); + if (_this->_impl_.asn_refresh_interval_ == nullptr) { + _this->_impl_.asn_refresh_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.asn_refresh_interval_); + } else { + _this->_impl_.asn_refresh_interval_->MergeFrom(*from._impl_.asn_refresh_interval_); + } + } + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_modulus() != 0) { _this->_impl_.modulus_ = from._impl_.modulus_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_envelope_flush_threshold_bytes() != 0) { _this->_impl_.envelope_flush_threshold_bytes_ = from._impl_.envelope_flush_threshold_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_s3_parquet_flush_threshold_bytes() != 0) { _this->_impl_.s3_parquet_flush_threshold_bytes_ = from._impl_.s3_parquet_flush_threshold_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_pyroscope_sample_hz() != 0) { _this->_impl_.pyroscope_sample_hz_ = from._impl_.pyroscope_sample_hz_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_pyroscope_upload_interval_sec() != 0) { _this->_impl_.pyroscope_upload_interval_sec_ = from._impl_.pyroscope_upload_interval_sec_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_debug_level() != 0) { _this->_impl_.debug_level_ = from._impl_.debug_level_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_ipv4_ttl() != 0) { _this->_impl_.ipv4_ttl_ = from._impl_.ipv4_ttl_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_ipv6_hop_limit() != 0) { _this->_impl_.ipv6_hop_limit_ = from._impl_.ipv6_hop_limit_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_s3_skip_bucket_probe() != 0) { _this->_impl_.s3_skip_bucket_probe_ = from._impl_.s3_skip_bucket_probe_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_resolve_container_id() != 0) { _this->_impl_.resolve_container_id_ = from._impl_.resolve_container_id_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_io_uring() != 0) { _this->_impl_.io_uring_ = from._impl_.io_uring_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_reconcile_before_poll() != 0) { _this->_impl_.reconcile_before_poll_ = from._impl_.reconcile_before_poll_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_grpc_port() != 0) { _this->_impl_.grpc_port_ = from._impl_.grpc_port_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_io_uring_recv_batch_size() != 0) { _this->_impl_.io_uring_recv_batch_size_ = from._impl_.io_uring_recv_batch_size_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_io_uring_cqe_batch_size() != 0) { _this->_impl_.io_uring_cqe_batch_size_ = from._impl_.io_uring_cqe_batch_size_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_poll_jitter_pct() != 0) { _this->_impl_.poll_jitter_pct_ = from._impl_.poll_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_s3_flush_jitter_pct() != 0) { _this->_impl_.s3_flush_jitter_pct_ = from._impl_.s3_flush_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_s3_flush_threshold_jitter_pct() != 0) { _this->_impl_.s3_flush_threshold_jitter_pct_ = from._impl_.s3_flush_threshold_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_s3_upload_max_attempts() != 0) { _this->_impl_.s3_upload_max_attempts_ = from._impl_.s3_upload_max_attempts_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_enrich_container_enable() != 0) { _this->_impl_.enrich_container_enable_ = from._impl_.enrich_container_enable_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + } + cached_has_bits = from._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (from._internal_enrich_lldp_enable() != 0) { _this->_impl_.enrich_lldp_enable_ = from._impl_.enrich_lldp_enable_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_enrich_nic_enable() != 0) { _this->_impl_.enrich_nic_enable_ = from._impl_.enrich_nic_enable_; } } - } - cached_has_bits = from._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_populate_nsid() != 0) { _this->_impl_.populate_nsid_ = from._impl_.populate_nsid_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_uplink_count() != 0) { _this->_impl_.uplink_count_ = from._impl_.uplink_count_; } } + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (from._internal_enrich_asn_enable() != 0) { + _this->_impl_.enrich_asn_enable_ = from._impl_.enrich_asn_enable_; + } + } } _this->_impl_._has_bits_.Or(from._impl_._has_bits_); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -8172,9 +8287,10 @@ void XtcpConfig::InternalSwap(XtcpConfig* PROTOBUF_RESTRICT PROTOBUF_NONNULL oth ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.docker_socket_path_, &other->_impl_.docker_socket_path_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.lldpd_socket_path_, &other->_impl_.lldpd_socket_path_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.lldpd_version_hint_, &other->_impl_.lldpd_version_hint_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.asn_db_path_, &other->_impl_.asn_db_path_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_) - + sizeof(XtcpConfig::_impl_.uplink_count_) + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_) + + sizeof(XtcpConfig::_impl_.enrich_asn_enable_) - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_)>( reinterpret_cast(&_impl_.kafka_produce_timeout_), reinterpret_cast(&other->_impl_.kafka_produce_timeout_)); diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h index 084f496..41cc4d8 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h @@ -2164,11 +2164,13 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: kDockerSocketPathFieldNumber = 231, kLldpdSocketPathFieldNumber = 233, kLldpdVersionHintFieldNumber = 234, + kAsnDbPathFieldNumber = 240, kKafkaProduceTimeoutFieldNumber = 150, kEnabledDeserializersFieldNumber = 200, kS3FlushIntervalFieldNumber = 222, kS3UploadBackoffCapFieldNumber = 226, kReconcileFrequencyFieldNumber = 227, + kAsnRefreshIntervalFieldNumber = 241, kModulusFieldNumber = 110, kEnvelopeFlushThresholdBytesFieldNumber = 122, kS3ParquetFlushThresholdBytesFieldNumber = 132, @@ -2193,6 +2195,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: kEnrichNicEnableFieldNumber = 235, kPopulateNsidFieldNumber = 238, kUplinkCountFieldNumber = 236, + kEnrichAsnEnableFieldNumber = 239, }; // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { void clear_s3_endpoint() ; @@ -2712,6 +2715,21 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: PROTOBUF_ALWAYS_INLINE void _internal_set_lldpd_version_hint(const ::std::string& value); ::std::string* PROTOBUF_NONNULL _internal_mutable_lldpd_version_hint(); + public: + // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { + void clear_asn_db_path() ; + [[nodiscard]] const ::std::string& asn_db_path() const; + template + void set_asn_db_path(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_asn_db_path(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_asn_db_path(); + void set_allocated_asn_db_path(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_asn_db_path() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_asn_db_path(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_asn_db_path(); + public: // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { [[nodiscard]] bool has_kafka_produce_timeout() @@ -2792,6 +2810,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: const ::google::protobuf::Duration& _internal_reconcile_frequency() const; ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_reconcile_frequency(); + public: + // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + [[nodiscard]] bool has_asn_refresh_interval() + const; + void clear_asn_refresh_interval() ; + [[nodiscard]] const ::google::protobuf::Duration& asn_refresh_interval() const; + [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_asn_refresh_interval(); + ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_asn_refresh_interval(); + void set_allocated_asn_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_asn_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_asn_refresh_interval(); + + private: + const ::google::protobuf::Duration& _internal_asn_refresh_interval() const; + ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_asn_refresh_interval(); + public: // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { void clear_modulus() ; @@ -3032,13 +3066,23 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::uint32_t _internal_uplink_count() const; void _internal_set_uplink_count(::uint32_t value); + public: + // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + void clear_enrich_asn_enable() ; + [[nodiscard]] bool enrich_asn_enable() const; + void set_enrich_asn_enable(bool value); + + private: + bool _internal_enrich_asn_enable() const; + void _internal_set_enrich_asn_enable(bool value); + public: // @@protoc_insertion_point(class_scope:xtcp_config.v1.XtcpConfig) private: class _Internal; using ParseTableT_ = - ::google::protobuf::internal::TcParseTable<5, 66, - 7, 391, + ::google::protobuf::internal::TcParseTable<5, 69, + 8, 402, 31>; static constexpr ParseTableT_ InternalGenerateParseTable_( const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data); @@ -3103,11 +3147,13 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::internal::ArenaStringPtr docker_socket_path_; ::google::protobuf::internal::ArenaStringPtr lldpd_socket_path_; ::google::protobuf::internal::ArenaStringPtr lldpd_version_hint_; + ::google::protobuf::internal::ArenaStringPtr asn_db_path_; ::google::protobuf::Duration* PROTOBUF_NULLABLE kafka_produce_timeout_; ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE enabled_deserializers_; ::google::protobuf::Duration* PROTOBUF_NULLABLE s3_flush_interval_; ::google::protobuf::Duration* PROTOBUF_NULLABLE s3_upload_backoff_cap_; ::google::protobuf::Duration* PROTOBUF_NULLABLE reconcile_frequency_; + ::google::protobuf::Duration* PROTOBUF_NULLABLE asn_refresh_interval_; ::uint64_t modulus_; ::uint32_t envelope_flush_threshold_bytes_; ::uint32_t s3_parquet_flush_threshold_bytes_; @@ -3132,6 +3178,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: bool enrich_nic_enable_; bool populate_nsid_; ::uint32_t uplink_count_; + bool enrich_asn_enable_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; @@ -6071,7 +6118,7 @@ inline void XtcpConfig::set_allocated_capture_path(::std::string* PROTOBUF_NULLA inline void XtcpConfig::clear_modulus() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.modulus_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); } inline ::uint64_t XtcpConfig::modulus() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.modulus) @@ -6079,7 +6126,7 @@ inline ::uint64_t XtcpConfig::modulus() const { } inline void XtcpConfig::set_modulus(::uint64_t value) { _internal_set_modulus(value); - SetHasBit(_impl_._has_bits_[1], 0x00000400U); + SetHasBit(_impl_._has_bits_[1], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.modulus) } inline ::uint64_t XtcpConfig::_internal_modulus() const { @@ -6159,7 +6206,7 @@ inline void XtcpConfig::set_allocated_marshal_to(::std::string* PROTOBUF_NULLABL inline void XtcpConfig::clear_envelope_flush_threshold_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.envelope_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); } inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) @@ -6167,7 +6214,7 @@ inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { } inline void XtcpConfig::set_envelope_flush_threshold_bytes(::uint32_t value) { _internal_set_envelope_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) } inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_bytes() const { @@ -6591,7 +6638,7 @@ inline void XtcpConfig::set_allocated_s3_secret_key(::std::string* PROTOBUF_NULL inline void XtcpConfig::clear_s3_parquet_flush_threshold_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_parquet_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) @@ -6599,7 +6646,7 @@ inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { } inline void XtcpConfig::set_s3_parquet_flush_threshold_bytes(::uint32_t value) { _internal_set_s3_parquet_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) } inline ::uint32_t XtcpConfig::_internal_s3_parquet_flush_threshold_bytes() const { @@ -6679,7 +6726,7 @@ inline void XtcpConfig::set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE inline void XtcpConfig::clear_s3_skip_bucket_probe() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_skip_bucket_probe_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00040000U); + ClearHasBit(_impl_._has_bits_[1], 0x00100000U); } inline bool XtcpConfig::s3_skip_bucket_probe() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) @@ -6687,7 +6734,7 @@ inline bool XtcpConfig::s3_skip_bucket_probe() const { } inline void XtcpConfig::set_s3_skip_bucket_probe(bool value) { _internal_set_s3_skip_bucket_probe(value); - SetHasBit(_impl_._has_bits_[1], 0x00040000U); + SetHasBit(_impl_._has_bits_[1], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) } inline bool XtcpConfig::_internal_s3_skip_bucket_probe() const { @@ -6831,7 +6878,7 @@ inline void XtcpConfig::set_allocated_pyroscope_app_name(::std::string* PROTOBUF inline void XtcpConfig::clear_pyroscope_sample_hz() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pyroscope_sample_hz_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) @@ -6839,7 +6886,7 @@ inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { } inline void XtcpConfig::set_pyroscope_sample_hz(::uint32_t value) { _internal_set_pyroscope_sample_hz(value); - SetHasBit(_impl_._has_bits_[1], 0x00002000U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) } inline ::uint32_t XtcpConfig::_internal_pyroscope_sample_hz() const { @@ -6855,7 +6902,7 @@ inline void XtcpConfig::_internal_set_pyroscope_sample_hz(::uint32_t value) { inline void XtcpConfig::clear_pyroscope_upload_interval_sec() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pyroscope_upload_interval_sec_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) @@ -6863,7 +6910,7 @@ inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { } inline void XtcpConfig::set_pyroscope_upload_interval_sec(::uint32_t value) { _internal_set_pyroscope_upload_interval_sec(value); - SetHasBit(_impl_._has_bits_[1], 0x00004000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) } inline ::uint32_t XtcpConfig::_internal_pyroscope_upload_interval_sec() const { @@ -7157,7 +7204,7 @@ inline void XtcpConfig::set_allocated_kafka_schema_url(::std::string* PROTOBUF_N // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { inline bool XtcpConfig::has_kafka_produce_timeout() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U); PROTOBUF_ASSUME(!value || _impl_.kafka_produce_timeout_ != nullptr); return value; } @@ -7178,16 +7225,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_kafka_produce_timeout( } _impl_.kafka_produce_timeout_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000040U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_kafka_produce_timeout() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); ::google::protobuf::Duration* released = _impl_.kafka_produce_timeout_; _impl_.kafka_produce_timeout_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -7207,7 +7254,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); ::google::protobuf::Duration* temp = _impl_.kafka_produce_timeout_; _impl_.kafka_produce_timeout_ = nullptr; return temp; @@ -7222,7 +7269,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_kafka_produce_timeout() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000040U); ::google::protobuf::Duration* _msg = _internal_mutable_kafka_produce_timeout(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) return _msg; @@ -7239,9 +7286,9 @@ inline void XtcpConfig::set_allocated_kafka_produce_timeout(::google::protobuf:: if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000040U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } _impl_.kafka_produce_timeout_ = reinterpret_cast<::google::protobuf::Duration*>(value); @@ -7252,7 +7299,7 @@ inline void XtcpConfig::set_allocated_kafka_produce_timeout(::google::protobuf:: inline void XtcpConfig::clear_debug_level() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.debug_level_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00008000U); + ClearHasBit(_impl_._has_bits_[1], 0x00020000U); } inline ::uint32_t XtcpConfig::debug_level() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.debug_level) @@ -7260,7 +7307,7 @@ inline ::uint32_t XtcpConfig::debug_level() const { } inline void XtcpConfig::set_debug_level(::uint32_t value) { _internal_set_debug_level(value); - SetHasBit(_impl_._has_bits_[1], 0x00008000U); + SetHasBit(_impl_._has_bits_[1], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.debug_level) } inline ::uint32_t XtcpConfig::_internal_debug_level() const { @@ -7596,7 +7643,7 @@ inline void XtcpConfig::set_allocated_daemon_version(::std::string* PROTOBUF_NUL inline void XtcpConfig::clear_resolve_container_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.resolve_container_id_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00080000U); + ClearHasBit(_impl_._has_bits_[1], 0x00200000U); } inline bool XtcpConfig::resolve_container_id() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.resolve_container_id) @@ -7604,7 +7651,7 @@ inline bool XtcpConfig::resolve_container_id() const { } inline void XtcpConfig::set_resolve_container_id(bool value) { _internal_set_resolve_container_id(value); - SetHasBit(_impl_._has_bits_[1], 0x00080000U); + SetHasBit(_impl_._has_bits_[1], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.resolve_container_id) } inline bool XtcpConfig::_internal_resolve_container_id() const { @@ -7620,7 +7667,7 @@ inline void XtcpConfig::_internal_set_resolve_container_id(bool value) { inline void XtcpConfig::clear_ipv4_ttl() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipv4_ttl_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00010000U); + ClearHasBit(_impl_._has_bits_[1], 0x00040000U); } inline ::uint32_t XtcpConfig::ipv4_ttl() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv4_ttl) @@ -7628,7 +7675,7 @@ inline ::uint32_t XtcpConfig::ipv4_ttl() const { } inline void XtcpConfig::set_ipv4_ttl(::uint32_t value) { _internal_set_ipv4_ttl(value); - SetHasBit(_impl_._has_bits_[1], 0x00010000U); + SetHasBit(_impl_._has_bits_[1], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv4_ttl) } inline ::uint32_t XtcpConfig::_internal_ipv4_ttl() const { @@ -7644,7 +7691,7 @@ inline void XtcpConfig::_internal_set_ipv4_ttl(::uint32_t value) { inline void XtcpConfig::clear_ipv6_hop_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipv6_hop_limit_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00020000U); + ClearHasBit(_impl_._has_bits_[1], 0x00080000U); } inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) @@ -7652,7 +7699,7 @@ inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { } inline void XtcpConfig::set_ipv6_hop_limit(::uint32_t value) { _internal_set_ipv6_hop_limit(value); - SetHasBit(_impl_._has_bits_[1], 0x00020000U); + SetHasBit(_impl_._has_bits_[1], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) } inline ::uint32_t XtcpConfig::_internal_ipv6_hop_limit() const { @@ -7668,7 +7715,7 @@ inline void XtcpConfig::_internal_set_ipv6_hop_limit(::uint32_t value) { inline void XtcpConfig::clear_grpc_port() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.grpc_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00400000U); + ClearHasBit(_impl_._has_bits_[1], 0x01000000U); } inline ::uint32_t XtcpConfig::grpc_port() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.grpc_port) @@ -7676,7 +7723,7 @@ inline ::uint32_t XtcpConfig::grpc_port() const { } inline void XtcpConfig::set_grpc_port(::uint32_t value) { _internal_set_grpc_port(value); - SetHasBit(_impl_._has_bits_[1], 0x00400000U); + SetHasBit(_impl_._has_bits_[1], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.grpc_port) } inline ::uint32_t XtcpConfig::_internal_grpc_port() const { @@ -7690,14 +7737,14 @@ inline void XtcpConfig::_internal_set_grpc_port(::uint32_t value) { // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { inline bool XtcpConfig::has_enabled_deserializers() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U); PROTOBUF_ASSUME(!value || _impl_.enabled_deserializers_ != nullptr); return value; } inline void XtcpConfig::clear_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.enabled_deserializers_ != nullptr) _impl_.enabled_deserializers_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } inline const ::xtcp_config::v1::EnabledDeserializers& XtcpConfig::_internal_enabled_deserializers() const { ::google::protobuf::internal::TSanRead(&_impl_); @@ -7716,16 +7763,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_enabled_deserializers( } _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.enabled_deserializers) } inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::release_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); ::xtcp_config::v1::EnabledDeserializers* released = _impl_.enabled_deserializers_; _impl_.enabled_deserializers_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -7745,7 +7792,7 @@ inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::un ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.enabled_deserializers) - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); ::xtcp_config::v1::EnabledDeserializers* temp = _impl_.enabled_deserializers_; _impl_.enabled_deserializers_ = nullptr; return temp; @@ -7760,7 +7807,7 @@ inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::_in } inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::mutable_enabled_deserializers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); ::xtcp_config::v1::EnabledDeserializers* _msg = _internal_mutable_enabled_deserializers(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.enabled_deserializers) return _msg; @@ -7777,9 +7824,9 @@ inline void XtcpConfig::set_allocated_enabled_deserializers(::xtcp_config::v1::E if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); @@ -7790,7 +7837,7 @@ inline void XtcpConfig::set_allocated_enabled_deserializers(::xtcp_config::v1::E inline void XtcpConfig::clear_io_uring() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00100000U); + ClearHasBit(_impl_._has_bits_[1], 0x00400000U); } inline bool XtcpConfig::io_uring() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring) @@ -7798,7 +7845,7 @@ inline bool XtcpConfig::io_uring() const { } inline void XtcpConfig::set_io_uring(bool value) { _internal_set_io_uring(value); - SetHasBit(_impl_._has_bits_[1], 0x00100000U); + SetHasBit(_impl_._has_bits_[1], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring) } inline bool XtcpConfig::_internal_io_uring() const { @@ -7814,7 +7861,7 @@ inline void XtcpConfig::_internal_set_io_uring(bool value) { inline void XtcpConfig::clear_io_uring_recv_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_recv_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00800000U); + ClearHasBit(_impl_._has_bits_[1], 0x02000000U); } inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) @@ -7822,7 +7869,7 @@ inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { } inline void XtcpConfig::set_io_uring_recv_batch_size(::uint32_t value) { _internal_set_io_uring_recv_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x00800000U); + SetHasBit(_impl_._has_bits_[1], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) } inline ::uint32_t XtcpConfig::_internal_io_uring_recv_batch_size() const { @@ -7838,7 +7885,7 @@ inline void XtcpConfig::_internal_set_io_uring_recv_batch_size(::uint32_t value) inline void XtcpConfig::clear_io_uring_cqe_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_cqe_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x01000000U); + ClearHasBit(_impl_._has_bits_[1], 0x04000000U); } inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) @@ -7846,7 +7893,7 @@ inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { } inline void XtcpConfig::set_io_uring_cqe_batch_size(::uint32_t value) { _internal_set_io_uring_cqe_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x01000000U); + SetHasBit(_impl_._has_bits_[1], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) } inline ::uint32_t XtcpConfig::_internal_io_uring_cqe_batch_size() const { @@ -7926,7 +7973,7 @@ inline void XtcpConfig::set_allocated_csv_columns(::std::string* PROTOBUF_NULLAB inline void XtcpConfig::clear_poll_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.poll_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x02000000U); + ClearHasBit(_impl_._has_bits_[1], 0x08000000U); } inline ::uint32_t XtcpConfig::poll_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.poll_jitter_pct) @@ -7934,7 +7981,7 @@ inline ::uint32_t XtcpConfig::poll_jitter_pct() const { } inline void XtcpConfig::set_poll_jitter_pct(::uint32_t value) { _internal_set_poll_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x02000000U); + SetHasBit(_impl_._has_bits_[1], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.poll_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_poll_jitter_pct() const { @@ -7948,7 +7995,7 @@ inline void XtcpConfig::_internal_set_poll_jitter_pct(::uint32_t value) { // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { inline bool XtcpConfig::has_s3_flush_interval() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U); PROTOBUF_ASSUME(!value || _impl_.s3_flush_interval_ != nullptr); return value; } @@ -7969,16 +8016,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_s3_flush_interval( } _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_flush_interval) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_flush_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); ::google::protobuf::Duration* released = _impl_.s3_flush_interval_; _impl_.s3_flush_interval_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -7998,7 +8045,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_flush_interval) - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); ::google::protobuf::Duration* temp = _impl_.s3_flush_interval_; _impl_.s3_flush_interval_ = nullptr; return temp; @@ -8013,7 +8060,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_flush_interval() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); ::google::protobuf::Duration* _msg = _internal_mutable_s3_flush_interval(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_flush_interval) return _msg; @@ -8030,9 +8077,9 @@ inline void XtcpConfig::set_allocated_s3_flush_interval(::google::protobuf::Dura if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); } _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); @@ -8043,7 +8090,7 @@ inline void XtcpConfig::set_allocated_s3_flush_interval(::google::protobuf::Dura inline void XtcpConfig::clear_s3_flush_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_flush_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x04000000U); + ClearHasBit(_impl_._has_bits_[1], 0x10000000U); } inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) @@ -8051,7 +8098,7 @@ inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { } inline void XtcpConfig::set_s3_flush_jitter_pct(::uint32_t value) { _internal_set_s3_flush_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x04000000U); + SetHasBit(_impl_._has_bits_[1], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_s3_flush_jitter_pct() const { @@ -8067,7 +8114,7 @@ inline void XtcpConfig::_internal_set_s3_flush_jitter_pct(::uint32_t value) { inline void XtcpConfig::clear_s3_flush_threshold_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_flush_threshold_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x08000000U); + ClearHasBit(_impl_._has_bits_[1], 0x20000000U); } inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) @@ -8075,7 +8122,7 @@ inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { } inline void XtcpConfig::set_s3_flush_threshold_jitter_pct(::uint32_t value) { _internal_set_s3_flush_threshold_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x08000000U); + SetHasBit(_impl_._has_bits_[1], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_s3_flush_threshold_jitter_pct() const { @@ -8091,7 +8138,7 @@ inline void XtcpConfig::_internal_set_s3_flush_threshold_jitter_pct(::uint32_t v inline void XtcpConfig::clear_s3_upload_max_attempts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_upload_max_attempts_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x10000000U); + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); } inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) @@ -8099,7 +8146,7 @@ inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { } inline void XtcpConfig::set_s3_upload_max_attempts(::uint32_t value) { _internal_set_s3_upload_max_attempts(value); - SetHasBit(_impl_._has_bits_[1], 0x10000000U); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) } inline ::uint32_t XtcpConfig::_internal_s3_upload_max_attempts() const { @@ -8113,7 +8160,7 @@ inline void XtcpConfig::_internal_set_s3_upload_max_attempts(::uint32_t value) { // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { inline bool XtcpConfig::has_s3_upload_backoff_cap() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U); PROTOBUF_ASSUME(!value || _impl_.s3_upload_backoff_cap_ != nullptr); return value; } @@ -8134,16 +8181,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_s3_upload_backoff_cap( } _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); ::google::protobuf::Duration* released = _impl_.s3_upload_backoff_cap_; _impl_.s3_upload_backoff_cap_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -8163,7 +8210,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); ::google::protobuf::Duration* temp = _impl_.s3_upload_backoff_cap_; _impl_.s3_upload_backoff_cap_ = nullptr; return temp; @@ -8178,7 +8225,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_upload_backoff_cap() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); ::google::protobuf::Duration* _msg = _internal_mutable_s3_upload_backoff_cap(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) return _msg; @@ -8195,9 +8242,9 @@ inline void XtcpConfig::set_allocated_s3_upload_backoff_cap(::google::protobuf:: if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); @@ -8206,7 +8253,7 @@ inline void XtcpConfig::set_allocated_s3_upload_backoff_cap(::google::protobuf:: // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { inline bool XtcpConfig::has_reconcile_frequency() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U); PROTOBUF_ASSUME(!value || _impl_.reconcile_frequency_ != nullptr); return value; } @@ -8227,16 +8274,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_reconcile_frequency( } _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.reconcile_frequency) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_reconcile_frequency() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); ::google::protobuf::Duration* released = _impl_.reconcile_frequency_; _impl_.reconcile_frequency_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -8256,7 +8303,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.reconcile_frequency) - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); ::google::protobuf::Duration* temp = _impl_.reconcile_frequency_; _impl_.reconcile_frequency_ = nullptr; return temp; @@ -8271,7 +8318,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_reconcile_frequency() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); ::google::protobuf::Duration* _msg = _internal_mutable_reconcile_frequency(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.reconcile_frequency) return _msg; @@ -8288,9 +8335,9 @@ inline void XtcpConfig::set_allocated_reconcile_frequency(::google::protobuf::Du if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000200U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); @@ -8301,7 +8348,7 @@ inline void XtcpConfig::set_allocated_reconcile_frequency(::google::protobuf::Du inline void XtcpConfig::clear_reconcile_before_poll() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reconcile_before_poll_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00200000U); + ClearHasBit(_impl_._has_bits_[1], 0x00800000U); } inline bool XtcpConfig::reconcile_before_poll() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_before_poll) @@ -8309,7 +8356,7 @@ inline bool XtcpConfig::reconcile_before_poll() const { } inline void XtcpConfig::set_reconcile_before_poll(bool value) { _internal_set_reconcile_before_poll(value); - SetHasBit(_impl_._has_bits_[1], 0x00200000U); + SetHasBit(_impl_._has_bits_[1], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.reconcile_before_poll) } inline bool XtcpConfig::_internal_reconcile_before_poll() const { @@ -8325,7 +8372,7 @@ inline void XtcpConfig::_internal_set_reconcile_before_poll(bool value) { inline void XtcpConfig::clear_enrich_container_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_container_enable_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x20000000U); + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } inline bool XtcpConfig::enrich_container_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_container_enable) @@ -8333,7 +8380,7 @@ inline bool XtcpConfig::enrich_container_enable() const { } inline void XtcpConfig::set_enrich_container_enable(bool value) { _internal_set_enrich_container_enable(value); - SetHasBit(_impl_._has_bits_[1], 0x20000000U); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_container_enable) } inline bool XtcpConfig::_internal_enrich_container_enable() const { @@ -8413,7 +8460,7 @@ inline void XtcpConfig::set_allocated_docker_socket_path(::std::string* PROTOBUF inline void XtcpConfig::clear_enrich_lldp_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_lldp_enable_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000001U); } inline bool XtcpConfig::enrich_lldp_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_lldp_enable) @@ -8421,7 +8468,7 @@ inline bool XtcpConfig::enrich_lldp_enable() const { } inline void XtcpConfig::set_enrich_lldp_enable(bool value) { _internal_set_enrich_lldp_enable(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_lldp_enable) } inline bool XtcpConfig::_internal_enrich_lldp_enable() const { @@ -8565,7 +8612,7 @@ inline void XtcpConfig::set_allocated_lldpd_version_hint(::std::string* PROTOBUF inline void XtcpConfig::clear_enrich_nic_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_nic_enable_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000002U); } inline bool XtcpConfig::enrich_nic_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_nic_enable) @@ -8573,7 +8620,7 @@ inline bool XtcpConfig::enrich_nic_enable() const { } inline void XtcpConfig::set_enrich_nic_enable(bool value) { _internal_set_enrich_nic_enable(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_nic_enable) } inline bool XtcpConfig::_internal_enrich_nic_enable() const { @@ -8589,7 +8636,7 @@ inline void XtcpConfig::_internal_set_enrich_nic_enable(bool value) { inline void XtcpConfig::clear_uplink_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink_count_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000002U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline ::uint32_t XtcpConfig::uplink_count() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.uplink_count) @@ -8597,7 +8644,7 @@ inline ::uint32_t XtcpConfig::uplink_count() const { } inline void XtcpConfig::set_uplink_count(::uint32_t value) { _internal_set_uplink_count(value); - SetHasBit(_impl_._has_bits_[2], 0x00000002U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.uplink_count) } inline ::uint32_t XtcpConfig::_internal_uplink_count() const { @@ -8685,7 +8732,7 @@ XtcpConfig::_internal_mutable_uplink_interfaces() { inline void XtcpConfig::clear_populate_nsid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.populate_nsid_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000001U); + ClearHasBit(_impl_._has_bits_[2], 0x00000004U); } inline bool XtcpConfig::populate_nsid() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.populate_nsid) @@ -8693,7 +8740,7 @@ inline bool XtcpConfig::populate_nsid() const { } inline void XtcpConfig::set_populate_nsid(bool value) { _internal_set_populate_nsid(value); - SetHasBit(_impl_._has_bits_[2], 0x00000001U); + SetHasBit(_impl_._has_bits_[2], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.populate_nsid) } inline bool XtcpConfig::_internal_populate_nsid() const { @@ -8705,6 +8752,187 @@ inline void XtcpConfig::_internal_set_populate_nsid(bool value) { _impl_.populate_nsid_ = value; } +// bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; +inline void XtcpConfig::clear_enrich_asn_enable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_asn_enable_ = false; + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); +} +inline bool XtcpConfig::enrich_asn_enable() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_asn_enable) + return _internal_enrich_asn_enable(); +} +inline void XtcpConfig::set_enrich_asn_enable(bool value) { + _internal_set_enrich_asn_enable(value); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_asn_enable) +} +inline bool XtcpConfig::_internal_enrich_asn_enable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.enrich_asn_enable_; +} +inline void XtcpConfig::_internal_set_enrich_asn_enable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_asn_enable_ = value; +} + +// string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { +inline void XtcpConfig::clear_asn_db_path() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.asn_db_path_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); +} +inline const ::std::string& XtcpConfig::asn_db_path() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.asn_db_path) + return _internal_asn_db_path(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_asn_db_path(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000020U); + _impl_.asn_db_path_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.asn_db_path) +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_asn_db_path() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000020U); + ::std::string* _s = _internal_mutable_asn_db_path(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.asn_db_path) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_asn_db_path() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.asn_db_path_.Get(); +} +inline void XtcpConfig::_internal_set_asn_db_path(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.asn_db_path_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_asn_db_path() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.asn_db_path_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_asn_db_path() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.asn_db_path) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000020U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + auto* released = _impl_.asn_db_path_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.asn_db_path_.Set("", GetArena()); + } + return released; +} +inline void XtcpConfig::set_allocated_asn_db_path(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000020U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + } + _impl_.asn_db_path_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.asn_db_path_.IsDefault()) { + _impl_.asn_db_path_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.asn_db_path) +} + +// .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; +inline bool XtcpConfig::has_asn_refresh_interval() const { + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U); + PROTOBUF_ASSUME(!value || _impl_.asn_refresh_interval_ != nullptr); + return value; +} +inline const ::google::protobuf::Duration& XtcpConfig::_internal_asn_refresh_interval() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Duration* p = _impl_.asn_refresh_interval_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); +} +inline const ::google::protobuf::Duration& XtcpConfig::asn_refresh_interval() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.asn_refresh_interval) + return _internal_asn_refresh_interval(); +} +inline void XtcpConfig::unsafe_arena_set_allocated_asn_refresh_interval( + ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.asn_refresh_interval_); + } + _impl_.asn_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.asn_refresh_interval) +} +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_asn_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* released = _impl_.asn_refresh_interval_; + _impl_.asn_refresh_interval_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_asn_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.asn_refresh_interval) + + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* temp = _impl_.asn_refresh_interval_; + _impl_.asn_refresh_interval_ = nullptr; + return temp; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_asn_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.asn_refresh_interval_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); + _impl_.asn_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(p); + } + return _impl_.asn_refresh_interval_; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_asn_refresh_interval() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* _msg = _internal_mutable_asn_refresh_interval(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.asn_refresh_interval) + return _msg; +} +inline void XtcpConfig::set_allocated_asn_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.asn_refresh_interval_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + } + + _impl_.asn_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.asn_refresh_interval) +} + // ------------------------------------------------------------------- // ------------------------------------------------------------------- diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc index 227cf5e..ee9e304 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc @@ -62,7 +62,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl offsetof(ParseTableT_, field_lookup_table), 535297532, // skipmap offsetof(ParseTableT_, field_entries), - 156, // num_field_entries + 157, // num_field_entries 0, // num_aux_entries offsetof(ParseTableT_, field_names), // no aux_entries class_data, @@ -177,36 +177,36 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl 65039, 38, 1001, 0, 7, 0, 43, - 65534, 59, - 65535, 60, - 65535, 60, - 65535, 60, - 65535, 60, - 65295, 60, + 65532, 59, + 65535, 61, + 65535, 61, + 65535, 61, + 65535, 61, + 65295, 61, 1201, 0, 7, - 15360, 64, - 0, 76, - 0, 92, - 0, 108, - 65534, 124, - 65535, 125, - 65511, 125, + 15360, 65, + 0, 77, + 0, 93, + 0, 109, + 65534, 125, + 65535, 126, + 65511, 126, 1401, 0, 1, - 65532, 127, + 65532, 128, 1501, 0, 1, - 65024, 129, + 65024, 130, 1600, 0, 1, - 65534, 138, + 65534, 139, 1701, 0, 1, - 65520, 139, + 65520, 140, 1801, 0, 1, - 65504, 143, + 65504, 144, 1901, 0, 1, - 65504, 148, + 65504, 149, 2001, 0, 1, - 65532, 153, + 65532, 154, 2103, 0, 1, - 65534, 155, + 65534, 156, 65535, 65535 }}, {{ // uint32 schema_version = 1 [json_name = "schemaVersion"]; @@ -242,7 +242,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // uint64 socket_fd = 61 [json_name = "socketFd"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.socket_fd_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // string uplink1_ifname = 100 [json_name = "uplink1Ifname"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_ifname_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink1_nic_driver = 101 [json_name = "uplink1NicDriver"]; @@ -252,11 +252,11 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_vendor_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_device_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_device_), _Internal::kHasBitsOffset + 43, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink1_nic_bus_info = 105 [json_name = "uplink1NicBusInfo"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_bus_info_), _Internal::kHasBitsOffset + 21, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_speed_mbps_), _Internal::kHasBitsOffset + 43, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_speed_mbps_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink1_nic_fw_version = 107 [json_name = "uplink1NicFwVersion"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_fw_version_), _Internal::kHasBitsOffset + 22, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink1_lldp_chassis_name = 120 [json_name = "uplink1LldpChassisName"]; @@ -276,13 +276,13 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // string uplink2_nic_model = 202 [json_name = "uplink2NicModel"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_model_), _Internal::kHasBitsOffset + 30, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_vendor_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_vendor_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_device_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_device_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink2_nic_bus_info = 205 [json_name = "uplink2NicBusInfo"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_bus_info_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_speed_mbps_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_speed_mbps_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink2_nic_fw_version = 207 [json_name = "uplink2NicFwVersion"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_fw_version_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink2_lldp_chassis_name = 220 [json_name = "uplink2LldpChassisName"]; @@ -296,17 +296,17 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // string uplink2_lldp_port_descr = 224 [json_name = "uplink2LldpPortDescr"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_lldp_port_descr_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_family_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_family_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_state_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_state_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_timer_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_timer_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_retrans_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_retrans_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_port_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_port_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_port_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_port_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_), _Internal::kHasBitsOffset + 38, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes inet_diag_msg_socket_destination = 1008 [json_name = "inetDiagMsgSocketDestination"]; @@ -314,217 +314,219 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_cookie_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_cookie_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_asn_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_asn_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_next_hop_asn_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_next_hop_asn_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_expires_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_expires_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_rqueue_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_rqueue_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_uid_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_uid_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_inode_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_inode_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_send_scale_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_send_scale_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_var_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_var_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_adv_mss_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_adv_mss_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pacing_rate_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pacing_rate_), _Internal::kHasBitsOffset + 100, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_max_pacing_rate_), _Internal::kHasBitsOffset + 100, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_max_pacing_rate_), _Internal::kHasBitsOffset + 101, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 101, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_), _Internal::kHasBitsOffset + 110, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_busy_time_), _Internal::kHasBitsOffset + 110, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_busy_time_), _Internal::kHasBitsOffset + 111, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 111, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_sent_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_sent_), _Internal::kHasBitsOffset + 116, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 116, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_dsack_dups_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_dsack_dups_), _Internal::kHasBitsOffset + 118, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 118, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_string_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_string_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_enum_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_enum_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.type_of_service_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.type_of_service_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.traffic_class_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.traffic_class_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.shutdown_state_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.shutdown_state_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_min_rtt_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_min_rtt_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 class_id = 2001 [json_name = "classId"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.class_id_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.class_id_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 c_group = 2103 [json_name = "cGroup"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_), _Internal::kHasBitsOffset + 156, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, // no aux_entries {{ - "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\33\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\47\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\33\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "xtcp_flat_record.v1.XtcpFlatRecord" "daemon_version" "hostname" @@ -556,6 +558,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl "uplink2_lldp_mgmt_ip" "uplink2_lldp_port_id" "uplink2_lldp_port_descr" + "inet_diag_msg_socket_dest_network_owner" "congestion_algorithm_string" }}, }; @@ -670,6 +673,9 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( inet_diag_msg_socket_destination_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), + inet_diag_msg_socket_dest_network_owner_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), congestion_algorithm_string_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -1590,7 +1596,7 @@ const ::uint32_t 0, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_._has_bits_), - 159, // hasbit index offset + 160, // hasbit index offset PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.schema_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.daemon_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.timestamp_ns_), @@ -1651,6 +1657,7 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_uid_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_inode_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_rmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_wmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_fmem_), @@ -1763,14 +1770,14 @@ const ::uint32_t 9, 15, 16, - 41, + 42, 19, 20, 10, 17, - 42, - 21, 43, + 21, + 44, 22, 23, 24, @@ -1780,34 +1787,34 @@ const ::uint32_t 28, 29, 30, - 44, 45, - 31, 46, + 31, + 47, 32, 33, 34, 35, 36, 37, - 47, 48, 49, 50, 51, 52, + 53, 38, 39, 18, - 54, 55, 56, - 53, 57, + 54, 58, 59, 60, 61, + 40, 62, 63, 64, @@ -1872,8 +1879,8 @@ const ::uint32_t 123, 124, 125, - 40, 126, + 41, 127, 128, 129, @@ -1903,6 +1910,7 @@ const ::uint32_t 153, 154, 155, + 156, 0x000, // bitmap 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::FlatRecordsResponse, _impl_._has_bits_), @@ -1921,10 +1929,10 @@ static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::xtcp_flat_record::v1::Envelope)}, {5, sizeof(::xtcp_flat_record::v1::XtcpFlatRecord)}, - {320, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, - {321, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, - {326, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, - {327, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, + {322, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, + {323, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, + {328, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, + {329, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, }; static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const file_message_globals[] = { @@ -1940,7 +1948,7 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr "\n*xtcp_flat_record/v1/xtcp_flat_record.p" "roto\022\023xtcp_flat_record.v1\"A\n\010Envelope\0225\n" "\003row\030\n \003(\0132#.xtcp_flat_record.v1.XtcpFla" - "tRecordR\003row\"\216<\n\016XtcpFlatRecord\022%\n\016schem" + "tRecordR\003row\"\343<\n\016XtcpFlatRecord\022%\n\016schem" "a_version\030\001 \001(\rR\rschemaVersion\022%\n\016daemon" "_version\030\002 \001(\tR\rdaemonVersion\022!\n\014timesta" "mp_ns\030\n \001(\003R\013timestampNs\022\032\n\010hostname\030\024 \001" @@ -2012,150 +2020,152 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr "Rqueue\0220\n\024inet_diag_msg_wqueue\030\367\007 \001(\rR\021i" "netDiagMsgWqueue\022*\n\021inet_diag_msg_uid\030\370\007" " \001(\rR\016inetDiagMsgUid\022.\n\023inet_diag_msg_in" - "ode\030\371\007 \001(\rR\020inetDiagMsgInode\022#\n\rmem_info" - "_rmem\030\315\010 \001(\rR\013memInfoRmem\022#\n\rmem_info_wm" - "em\030\316\010 \001(\rR\013memInfoWmem\022#\n\rmem_info_fmem\030" - "\317\010 \001(\rR\013memInfoFmem\022#\n\rmem_info_tmem\030\320\010 " - "\001(\rR\013memInfoTmem\022%\n\016tcp_info_state\030\261\t \001(" - "\rR\014tcpInfoState\022*\n\021tcp_info_ca_state\030\262\t " - "\001(\rR\016tcpInfoCaState\0221\n\024tcp_info_retransm" - "its\030\263\t \001(\rR\022tcpInfoRetransmits\022\'\n\017tcp_in" - "fo_probes\030\264\t \001(\rR\rtcpInfoProbes\022)\n\020tcp_i" - "nfo_backoff\030\265\t \001(\rR\016tcpInfoBackoff\022)\n\020tc" - "p_info_options\030\266\t \001(\rR\016tcpInfoOptions\022.\n" - "\023tcp_info_send_scale\030\267\t \001(\rR\020tcpInfoSend" - "Scale\022,\n\022tcp_info_rcv_scale\030\270\t \001(\rR\017tcpI" - "nfoRcvScale\022J\n\"tcp_info_delivery_rate_ap" - "p_limited\030\271\t \001(\rR\035tcpInfoDeliveryRateApp" - "Limited\022F\n tcp_info_fast_open_client_fai" - "led\030\272\t \001(\rR\033tcpInfoFastOpenClientFailed\022" - "!\n\014tcp_info_rto\030\277\t \001(\rR\ntcpInfoRto\022!\n\014tc" - "p_info_ato\030\300\t \001(\rR\ntcpInfoAto\022(\n\020tcp_inf" - "o_snd_mss\030\301\t \001(\rR\rtcpInfoSndMss\022(\n\020tcp_i" - "nfo_rcv_mss\030\302\t \001(\rR\rtcpInfoRcvMss\022)\n\020tcp" - "_info_unacked\030\303\t \001(\rR\016tcpInfoUnacked\022\'\n\017" - "tcp_info_sacked\030\304\t \001(\rR\rtcpInfoSacked\022#\n" - "\rtcp_info_lost\030\305\t \001(\rR\013tcpInfoLost\022)\n\020tc" - "p_info_retrans\030\306\t \001(\rR\016tcpInfoRetrans\022)\n" - "\020tcp_info_fackets\030\307\t \001(\rR\016tcpInfoFackets" - "\0225\n\027tcp_info_last_data_sent\030\310\t \001(\rR\023tcpI" - "nfoLastDataSent\0223\n\026tcp_info_last_ack_sen" - "t\030\311\t \001(\rR\022tcpInfoLastAckSent\0225\n\027tcp_info" - "_last_data_recv\030\312\t \001(\rR\023tcpInfoLastDataR" - "ecv\0223\n\026tcp_info_last_ack_recv\030\313\t \001(\rR\022tc" - "pInfoLastAckRecv\022#\n\rtcp_info_pmtu\030\314\t \001(\r" - "R\013tcpInfoPmtu\0222\n\025tcp_info_rcv_ssthresh\030\315" - "\t \001(\rR\022tcpInfoRcvSsthresh\022!\n\014tcp_info_rt" - "t\030\316\t \001(\rR\ntcpInfoRtt\022(\n\020tcp_info_rtt_var" - "\030\317\t \001(\rR\rtcpInfoRttVar\0222\n\025tcp_info_snd_s" - "sthresh\030\320\t \001(\rR\022tcpInfoSndSsthresh\022*\n\021tc" - "p_info_snd_cwnd\030\321\t \001(\rR\016tcpInfoSndCwnd\022(" - "\n\020tcp_info_adv_mss\030\322\t \001(\rR\rtcpInfoAdvMss" - "\022/\n\023tcp_info_reordering\030\323\t \001(\rR\021tcpInfoR" - "eordering\022(\n\020tcp_info_rcv_rtt\030\324\t \001(\rR\rtc" - "pInfoRcvRtt\022,\n\022tcp_info_rcv_space\030\325\t \001(\r" - "R\017tcpInfoRcvSpace\0224\n\026tcp_info_total_retr" - "ans\030\326\t \001(\rR\023tcpInfoTotalRetrans\0220\n\024tcp_i" - "nfo_pacing_rate\030\327\t \001(\004R\021tcpInfoPacingRat" - "e\0227\n\030tcp_info_max_pacing_rate\030\330\t \001(\004R\024tc" - "pInfoMaxPacingRate\0220\n\024tcp_info_bytes_ack" - "ed\030\331\t \001(\004R\021tcpInfoBytesAcked\0226\n\027tcp_info" - "_bytes_received\030\332\t \001(\004R\024tcpInfoBytesRece" - "ived\022*\n\021tcp_info_segs_out\030\333\t \001(\rR\016tcpInf" - "oSegsOut\022(\n\020tcp_info_segs_in\030\334\t \001(\rR\rtcp" - "InfoSegsIn\0225\n\027tcp_info_not_sent_bytes\030\335\t" - " \001(\rR\023tcpInfoNotSentBytes\022(\n\020tcp_info_mi" - "n_rtt\030\336\t \001(\rR\rtcpInfoMinRtt\0221\n\025tcp_info_" - "data_segs_in\030\337\t \001(\rR\021tcpInfoDataSegsIn\0223" - "\n\026tcp_info_data_segs_out\030\340\t \001(\rR\022tcpInfo" - "DataSegsOut\0224\n\026tcp_info_delivery_rate\030\341\t" - " \001(\004R\023tcpInfoDeliveryRate\022,\n\022tcp_info_bu" - "sy_time\030\342\t \001(\004R\017tcpInfoBusyTime\0222\n\025tcp_i" - "nfo_rwnd_limited\030\343\t \001(\004R\022tcpInfoRwndLimi" - "ted\0226\n\027tcp_info_sndbuf_limited\030\344\t \001(\004R\024t" - "cpInfoSndbufLimited\022-\n\022tcp_info_delivere" - "d\030\345\t \001(\rR\020tcpInfoDelivered\0222\n\025tcp_info_d" - "elivered_ce\030\346\t \001(\rR\022tcpInfoDeliveredCe\022." - "\n\023tcp_info_bytes_sent\030\347\t \001(\004R\020tcpInfoByt" - "esSent\0224\n\026tcp_info_bytes_retrans\030\350\t \001(\004R" - "\023tcpInfoBytesRetrans\022.\n\023tcp_info_dsack_d" - "ups\030\351\t \001(\rR\020tcpInfoDsackDups\022.\n\023tcp_info" - "_reord_seen\030\352\t \001(\rR\020tcpInfoReordSeen\0220\n\024" - "tcp_info_rcv_ooopack\030\353\t \001(\rR\021tcpInfoRcvO" - "oopack\022(\n\020tcp_info_snd_wnd\030\354\t \001(\rR\rtcpIn" - "foSndWnd\022(\n\020tcp_info_rcv_wnd\030\355\t \001(\rR\rtcp" - "InfoRcvWnd\022\'\n\017tcp_info_rehash\030\356\t \001(\rR\rtc" - "pInfoRehash\022,\n\022tcp_info_total_rto\030\357\t \001(\r" - "R\017tcpInfoTotalRto\022A\n\035tcp_info_total_rto_" - "recoveries\030\360\t \001(\rR\031tcpInfoTotalRtoRecove" - "ries\0225\n\027tcp_info_total_rto_time\030\361\t \001(\rR\023" - "tcpInfoTotalRtoTime\022\?\n\033congestion_algori" - "thm_string\030\224\n \001(\tR\031congestionAlgorithmSt" - "ring\022t\n\031congestion_algorithm_enum\030\225\n \001(\016" - "27.xtcp_flat_record.v1.XtcpFlatRecord.Co" - "ngestionAlgorithmR\027congestionAlgorithmEn" - "um\022\'\n\017type_of_service\030\371\n \001(\rR\rtypeOfServ" - "ice\022$\n\rtraffic_class\030\372\n \001(\rR\014trafficClas" - "s\0223\n\026sk_mem_info_rmem_alloc\030\335\013 \001(\rR\022skMe" - "mInfoRmemAlloc\022-\n\023sk_mem_info_rcv_buf\030\336\013" - " \001(\rR\017skMemInfoRcvBuf\0223\n\026sk_mem_info_wme" - "m_alloc\030\337\013 \001(\rR\022skMemInfoWmemAlloc\022-\n\023sk" - "_mem_info_snd_buf\030\340\013 \001(\rR\017skMemInfoSndBu" - "f\0221\n\025sk_mem_info_fwd_alloc\030\341\013 \001(\rR\021skMem" - "InfoFwdAlloc\0225\n\027sk_mem_info_wmem_queued\030" - "\342\013 \001(\rR\023skMemInfoWmemQueued\022,\n\022sk_mem_in" - "fo_optmem\030\343\013 \001(\rR\017skMemInfoOptmem\022.\n\023sk_" - "mem_info_backlog\030\344\013 \001(\rR\020skMemInfoBacklo" - "g\022*\n\021sk_mem_info_drops\030\345\013 \001(\rR\016skMemInfo" - "Drops\022&\n\016shutdown_state\030\300\014 \001(\rR\rshutdown" - "State\022-\n\022vegas_info_enabled\030\245\r \001(\rR\020vega" - "sInfoEnabled\022,\n\022vegas_info_rtt_cnt\030\246\r \001(" - "\rR\017vegasInfoRttCnt\022%\n\016vegas_info_rtt\030\247\r " - "\001(\rR\014vegasInfoRtt\022,\n\022vegas_info_min_rtt\030" - "\250\r \001(\rR\017vegasInfoMinRtt\022-\n\022dctcp_info_en" - "abled\030\211\016 \001(\rR\020dctcpInfoEnabled\022.\n\023dctcp_" - "info_ce_state\030\212\016 \001(\rR\020dctcpInfoCeState\022)" - "\n\020dctcp_info_alpha\030\213\016 \001(\rR\016dctcpInfoAlph" - "a\022*\n\021dctcp_info_ab_ecn\030\214\016 \001(\rR\016dctcpInfo" - "AbEcn\022*\n\021dctcp_info_ab_tot\030\215\016 \001(\rR\016dctcp" - "InfoAbTot\022$\n\016bbr_info_bw_lo\030\355\016 \001(\rR\013bbrI" - "nfoBwLo\022$\n\016bbr_info_bw_hi\030\356\016 \001(\rR\013bbrInf" - "oBwHi\022(\n\020bbr_info_min_rtt\030\357\016 \001(\rR\rbbrInf" - "oMinRtt\0220\n\024bbr_info_pacing_gain\030\360\016 \001(\rR\021" - "bbrInfoPacingGain\022,\n\022bbr_info_cwnd_gain\030" - "\361\016 \001(\rR\017bbrInfoCwndGain\022\032\n\010class_id\030\321\017 \001" - "(\rR\007classId\022\032\n\010sock_opt\030\322\017 \001(\rR\007sockOpt\022" - "\030\n\007c_group\030\267\020 \001(\004R\006cGroup\"\231\002\n\023Congestion" - "Algorithm\022$\n CONGESTION_ALGORITHM_UNSPEC" - "IFIED\020\000\022\036\n\032CONGESTION_ALGORITHM_CUBIC\020\001\022" - "\036\n\032CONGESTION_ALGORITHM_DCTCP\020\002\022\036\n\032CONGE" - "STION_ALGORITHM_VEGAS\020\003\022\037\n\033CONGESTION_AL" - "GORITHM_PRAGUE\020\004\022\035\n\031CONGESTION_ALGORITHM" - "_BBR1\020\005\022\035\n\031CONGESTION_ALGORITHM_BBR2\020\006\022\035" - "\n\031CONGESTION_ALGORITHM_BBR3\020\007\"\024\n\022FlatRec" - "ordsRequest\"d\n\023FlatRecordsResponse\022M\n\020xt" - "cp_flat_record\030\001 \001(\0132#.xtcp_flat_record." - "v1.XtcpFlatRecordR\016xtcpFlatRecord\"\030\n\026Pol" - "lFlatRecordsRequest\"h\n\027PollFlatRecordsRe" - "sponse\022M\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp_" - "flat_record.v1.XtcpFlatRecordR\016xtcpFlatR" - "ecord2\355\001\n\025XTCPFlatRecordService\022b\n\013FlatR" - "ecords\022\'.xtcp_flat_record.v1.FlatRecords" - "Request\032(.xtcp_flat_record.v1.FlatRecord" - "sResponse0\001\022p\n\017PollFlatRecords\022+.xtcp_fl" - "at_record.v1.PollFlatRecordsRequest\032,.xt" - "cp_flat_record.v1.PollFlatRecordsRespons" - "e(\0010\001B\256\001\n\027com.xtcp_flat_record.v1B\023XtcpF" - "latRecordProtoP\001Z\031./gen/go/xtcp_flat_rec" - "ord\242\002\003XXX\252\002\021XtcpFlatRecord.V1\312\002\021XtcpFlat" - "Record\\V1\342\002\035XtcpFlatRecord\\V1\\GPBMetadat" - "a\352\002\022XtcpFlatRecord::V1b\006proto3" + "ode\030\371\007 \001(\rR\020inetDiagMsgInode\022S\n\'inet_dia" + "g_msg_socket_dest_network_owner\030\372\007 \001(\tR!" + "inetDiagMsgSocketDestNetworkOwner\022#\n\rmem" + "_info_rmem\030\315\010 \001(\rR\013memInfoRmem\022#\n\rmem_in" + "fo_wmem\030\316\010 \001(\rR\013memInfoWmem\022#\n\rmem_info_" + "fmem\030\317\010 \001(\rR\013memInfoFmem\022#\n\rmem_info_tme" + "m\030\320\010 \001(\rR\013memInfoTmem\022%\n\016tcp_info_state\030" + "\261\t \001(\rR\014tcpInfoState\022*\n\021tcp_info_ca_stat" + "e\030\262\t \001(\rR\016tcpInfoCaState\0221\n\024tcp_info_ret" + "ransmits\030\263\t \001(\rR\022tcpInfoRetransmits\022\'\n\017t" + "cp_info_probes\030\264\t \001(\rR\rtcpInfoProbes\022)\n\020" + "tcp_info_backoff\030\265\t \001(\rR\016tcpInfoBackoff\022" + ")\n\020tcp_info_options\030\266\t \001(\rR\016tcpInfoOptio" + "ns\022.\n\023tcp_info_send_scale\030\267\t \001(\rR\020tcpInf" + "oSendScale\022,\n\022tcp_info_rcv_scale\030\270\t \001(\rR" + "\017tcpInfoRcvScale\022J\n\"tcp_info_delivery_ra" + "te_app_limited\030\271\t \001(\rR\035tcpInfoDeliveryRa" + "teAppLimited\022F\n tcp_info_fast_open_clien" + "t_failed\030\272\t \001(\rR\033tcpInfoFastOpenClientFa" + "iled\022!\n\014tcp_info_rto\030\277\t \001(\rR\ntcpInfoRto\022" + "!\n\014tcp_info_ato\030\300\t \001(\rR\ntcpInfoAto\022(\n\020tc" + "p_info_snd_mss\030\301\t \001(\rR\rtcpInfoSndMss\022(\n\020" + "tcp_info_rcv_mss\030\302\t \001(\rR\rtcpInfoRcvMss\022)" + "\n\020tcp_info_unacked\030\303\t \001(\rR\016tcpInfoUnacke" + "d\022\'\n\017tcp_info_sacked\030\304\t \001(\rR\rtcpInfoSack" + "ed\022#\n\rtcp_info_lost\030\305\t \001(\rR\013tcpInfoLost\022" + ")\n\020tcp_info_retrans\030\306\t \001(\rR\016tcpInfoRetra" + "ns\022)\n\020tcp_info_fackets\030\307\t \001(\rR\016tcpInfoFa" + "ckets\0225\n\027tcp_info_last_data_sent\030\310\t \001(\rR" + "\023tcpInfoLastDataSent\0223\n\026tcp_info_last_ac" + "k_sent\030\311\t \001(\rR\022tcpInfoLastAckSent\0225\n\027tcp" + "_info_last_data_recv\030\312\t \001(\rR\023tcpInfoLast" + "DataRecv\0223\n\026tcp_info_last_ack_recv\030\313\t \001(" + "\rR\022tcpInfoLastAckRecv\022#\n\rtcp_info_pmtu\030\314" + "\t \001(\rR\013tcpInfoPmtu\0222\n\025tcp_info_rcv_ssthr" + "esh\030\315\t \001(\rR\022tcpInfoRcvSsthresh\022!\n\014tcp_in" + "fo_rtt\030\316\t \001(\rR\ntcpInfoRtt\022(\n\020tcp_info_rt" + "t_var\030\317\t \001(\rR\rtcpInfoRttVar\0222\n\025tcp_info_" + "snd_ssthresh\030\320\t \001(\rR\022tcpInfoSndSsthresh\022" + "*\n\021tcp_info_snd_cwnd\030\321\t \001(\rR\016tcpInfoSndC" + "wnd\022(\n\020tcp_info_adv_mss\030\322\t \001(\rR\rtcpInfoA" + "dvMss\022/\n\023tcp_info_reordering\030\323\t \001(\rR\021tcp" + "InfoReordering\022(\n\020tcp_info_rcv_rtt\030\324\t \001(" + "\rR\rtcpInfoRcvRtt\022,\n\022tcp_info_rcv_space\030\325" + "\t \001(\rR\017tcpInfoRcvSpace\0224\n\026tcp_info_total" + "_retrans\030\326\t \001(\rR\023tcpInfoTotalRetrans\0220\n\024" + "tcp_info_pacing_rate\030\327\t \001(\004R\021tcpInfoPaci" + "ngRate\0227\n\030tcp_info_max_pacing_rate\030\330\t \001(" + "\004R\024tcpInfoMaxPacingRate\0220\n\024tcp_info_byte" + "s_acked\030\331\t \001(\004R\021tcpInfoBytesAcked\0226\n\027tcp" + "_info_bytes_received\030\332\t \001(\004R\024tcpInfoByte" + "sReceived\022*\n\021tcp_info_segs_out\030\333\t \001(\rR\016t" + "cpInfoSegsOut\022(\n\020tcp_info_segs_in\030\334\t \001(\r" + "R\rtcpInfoSegsIn\0225\n\027tcp_info_not_sent_byt" + "es\030\335\t \001(\rR\023tcpInfoNotSentBytes\022(\n\020tcp_in" + "fo_min_rtt\030\336\t \001(\rR\rtcpInfoMinRtt\0221\n\025tcp_" + "info_data_segs_in\030\337\t \001(\rR\021tcpInfoDataSeg" + "sIn\0223\n\026tcp_info_data_segs_out\030\340\t \001(\rR\022tc" + "pInfoDataSegsOut\0224\n\026tcp_info_delivery_ra" + "te\030\341\t \001(\004R\023tcpInfoDeliveryRate\022,\n\022tcp_in" + "fo_busy_time\030\342\t \001(\004R\017tcpInfoBusyTime\0222\n\025" + "tcp_info_rwnd_limited\030\343\t \001(\004R\022tcpInfoRwn" + "dLimited\0226\n\027tcp_info_sndbuf_limited\030\344\t \001" + "(\004R\024tcpInfoSndbufLimited\022-\n\022tcp_info_del" + "ivered\030\345\t \001(\rR\020tcpInfoDelivered\0222\n\025tcp_i" + "nfo_delivered_ce\030\346\t \001(\rR\022tcpInfoDelivere" + "dCe\022.\n\023tcp_info_bytes_sent\030\347\t \001(\004R\020tcpIn" + "foBytesSent\0224\n\026tcp_info_bytes_retrans\030\350\t" + " \001(\004R\023tcpInfoBytesRetrans\022.\n\023tcp_info_ds" + "ack_dups\030\351\t \001(\rR\020tcpInfoDsackDups\022.\n\023tcp" + "_info_reord_seen\030\352\t \001(\rR\020tcpInfoReordSee" + "n\0220\n\024tcp_info_rcv_ooopack\030\353\t \001(\rR\021tcpInf" + "oRcvOoopack\022(\n\020tcp_info_snd_wnd\030\354\t \001(\rR\r" + "tcpInfoSndWnd\022(\n\020tcp_info_rcv_wnd\030\355\t \001(\r" + "R\rtcpInfoRcvWnd\022\'\n\017tcp_info_rehash\030\356\t \001(" + "\rR\rtcpInfoRehash\022,\n\022tcp_info_total_rto\030\357" + "\t \001(\rR\017tcpInfoTotalRto\022A\n\035tcp_info_total" + "_rto_recoveries\030\360\t \001(\rR\031tcpInfoTotalRtoR" + "ecoveries\0225\n\027tcp_info_total_rto_time\030\361\t " + "\001(\rR\023tcpInfoTotalRtoTime\022\?\n\033congestion_a" + "lgorithm_string\030\224\n \001(\tR\031congestionAlgori" + "thmString\022t\n\031congestion_algorithm_enum\030\225" + "\n \001(\01627.xtcp_flat_record.v1.XtcpFlatReco" + "rd.CongestionAlgorithmR\027congestionAlgori" + "thmEnum\022\'\n\017type_of_service\030\371\n \001(\rR\rtypeO" + "fService\022$\n\rtraffic_class\030\372\n \001(\rR\014traffi" + "cClass\0223\n\026sk_mem_info_rmem_alloc\030\335\013 \001(\rR" + "\022skMemInfoRmemAlloc\022-\n\023sk_mem_info_rcv_b" + "uf\030\336\013 \001(\rR\017skMemInfoRcvBuf\0223\n\026sk_mem_inf" + "o_wmem_alloc\030\337\013 \001(\rR\022skMemInfoWmemAlloc\022" + "-\n\023sk_mem_info_snd_buf\030\340\013 \001(\rR\017skMemInfo" + "SndBuf\0221\n\025sk_mem_info_fwd_alloc\030\341\013 \001(\rR\021" + "skMemInfoFwdAlloc\0225\n\027sk_mem_info_wmem_qu" + "eued\030\342\013 \001(\rR\023skMemInfoWmemQueued\022,\n\022sk_m" + "em_info_optmem\030\343\013 \001(\rR\017skMemInfoOptmem\022." + "\n\023sk_mem_info_backlog\030\344\013 \001(\rR\020skMemInfoB" + "acklog\022*\n\021sk_mem_info_drops\030\345\013 \001(\rR\016skMe" + "mInfoDrops\022&\n\016shutdown_state\030\300\014 \001(\rR\rshu" + "tdownState\022-\n\022vegas_info_enabled\030\245\r \001(\rR" + "\020vegasInfoEnabled\022,\n\022vegas_info_rtt_cnt\030" + "\246\r \001(\rR\017vegasInfoRttCnt\022%\n\016vegas_info_rt" + "t\030\247\r \001(\rR\014vegasInfoRtt\022,\n\022vegas_info_min" + "_rtt\030\250\r \001(\rR\017vegasInfoMinRtt\022-\n\022dctcp_in" + "fo_enabled\030\211\016 \001(\rR\020dctcpInfoEnabled\022.\n\023d" + "ctcp_info_ce_state\030\212\016 \001(\rR\020dctcpInfoCeSt" + "ate\022)\n\020dctcp_info_alpha\030\213\016 \001(\rR\016dctcpInf" + "oAlpha\022*\n\021dctcp_info_ab_ecn\030\214\016 \001(\rR\016dctc" + "pInfoAbEcn\022*\n\021dctcp_info_ab_tot\030\215\016 \001(\rR\016" + "dctcpInfoAbTot\022$\n\016bbr_info_bw_lo\030\355\016 \001(\rR" + "\013bbrInfoBwLo\022$\n\016bbr_info_bw_hi\030\356\016 \001(\rR\013b" + "brInfoBwHi\022(\n\020bbr_info_min_rtt\030\357\016 \001(\rR\rb" + "brInfoMinRtt\0220\n\024bbr_info_pacing_gain\030\360\016 " + "\001(\rR\021bbrInfoPacingGain\022,\n\022bbr_info_cwnd_" + "gain\030\361\016 \001(\rR\017bbrInfoCwndGain\022\032\n\010class_id" + "\030\321\017 \001(\rR\007classId\022\032\n\010sock_opt\030\322\017 \001(\rR\007soc" + "kOpt\022\030\n\007c_group\030\267\020 \001(\004R\006cGroup\"\231\002\n\023Conge" + "stionAlgorithm\022$\n CONGESTION_ALGORITHM_U" + "NSPECIFIED\020\000\022\036\n\032CONGESTION_ALGORITHM_CUB" + "IC\020\001\022\036\n\032CONGESTION_ALGORITHM_DCTCP\020\002\022\036\n\032" + "CONGESTION_ALGORITHM_VEGAS\020\003\022\037\n\033CONGESTI" + "ON_ALGORITHM_PRAGUE\020\004\022\035\n\031CONGESTION_ALGO" + "RITHM_BBR1\020\005\022\035\n\031CONGESTION_ALGORITHM_BBR" + "2\020\006\022\035\n\031CONGESTION_ALGORITHM_BBR3\020\007\"\024\n\022Fl" + "atRecordsRequest\"d\n\023FlatRecordsResponse\022" + "M\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp_flat_re" + "cord.v1.XtcpFlatRecordR\016xtcpFlatRecord\"\030" + "\n\026PollFlatRecordsRequest\"h\n\027PollFlatReco" + "rdsResponse\022M\n\020xtcp_flat_record\030\001 \001(\0132#." + "xtcp_flat_record.v1.XtcpFlatRecordR\016xtcp" + "FlatRecord2\355\001\n\025XTCPFlatRecordService\022b\n\013" + "FlatRecords\022\'.xtcp_flat_record.v1.FlatRe" + "cordsRequest\032(.xtcp_flat_record.v1.FlatR" + "ecordsResponse0\001\022p\n\017PollFlatRecords\022+.xt" + "cp_flat_record.v1.PollFlatRecordsRequest" + "\032,.xtcp_flat_record.v1.PollFlatRecordsRe" + "sponse(\0010\001B\256\001\n\027com.xtcp_flat_record.v1B\023" + "XtcpFlatRecordProtoP\001Z\031./gen/go/xtcp_fla" + "t_record\242\002\003XXX\252\002\021XtcpFlatRecord.V1\312\002\021Xtc" + "pFlatRecord\\V1\342\002\035XtcpFlatRecord\\V1\\GPBMe" + "tadata\352\002\022XtcpFlatRecord::V1b\006proto3" }; static ::absl::once_flag descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto = { false, false, - 8510, + 8595, descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto, "xtcp_flat_record/v1/xtcp_flat_record.proto", &descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once, @@ -2448,6 +2458,7 @@ PROTOBUF_NDEBUG_INLINE XtcpFlatRecord::Impl_::Impl_( uplink2_lldp_port_descr_(arena, from.uplink2_lldp_port_descr_), inet_diag_msg_socket_source_(arena, from.inet_diag_msg_socket_source_), inet_diag_msg_socket_destination_(arena, from.inet_diag_msg_socket_destination_), + inet_diag_msg_socket_dest_network_owner_(arena, from.inet_diag_msg_socket_dest_network_owner_), congestion_algorithm_string_(arena, from.congestion_algorithm_string_) {} XtcpFlatRecord::XtcpFlatRecord( @@ -2517,6 +2528,7 @@ PROTOBUF_NDEBUG_INLINE XtcpFlatRecord::Impl_::Impl_( uplink2_lldp_port_descr_(arena), inet_diag_msg_socket_source_(arena), inet_diag_msg_socket_destination_(arena), + inet_diag_msg_socket_dest_network_owner_(arena), congestion_algorithm_string_(arena) {} inline void XtcpFlatRecord::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { @@ -2577,6 +2589,7 @@ inline void XtcpFlatRecord::SharedDtor(MessageLite& self) { this_._impl_.uplink2_lldp_port_descr_.Destroy(); this_._impl_.inet_diag_msg_socket_source_.Destroy(); this_._impl_.inet_diag_msg_socket_destination_.Destroy(); + this_._impl_.inet_diag_msg_socket_dest_network_owner_.Destroy(); this_._impl_.congestion_algorithm_string_.Destroy(); this_._impl_.~Impl_(); } @@ -2730,86 +2743,91 @@ PROTOBUF_NOINLINE void XtcpFlatRecord::Clear() { _impl_.inet_diag_msg_socket_destination_.ClearNonDefaultToEmpty(); } } - if (CheckHasBit(cached_has_bits, 0x00000100U)) { - _impl_.congestion_algorithm_string_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { + _impl_.inet_diag_msg_socket_dest_network_owner_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000200U)) { + _impl_.congestion_algorithm_string_.ClearNonDefaultToEmpty(); + } } - if (BatchCheckHasBit(cached_has_bits, 0x0000fe00U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000fc00U)) { ::memset(&_impl_.netlinker_id_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.inet_diag_msg_family_) - - reinterpret_cast(&_impl_.netlinker_id_)) + sizeof(_impl_.inet_diag_msg_family_)); + reinterpret_cast(&_impl_.uplink2_nic_speed_mbps_) - + reinterpret_cast(&_impl_.netlinker_id_)) + sizeof(_impl_.uplink2_nic_speed_mbps_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.inet_diag_msg_state_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.inet_diag_msg_socket_dest_asn_) - - reinterpret_cast(&_impl_.inet_diag_msg_state_)) + sizeof(_impl_.inet_diag_msg_socket_dest_asn_)); + ::memset(&_impl_.inet_diag_msg_family_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.inet_diag_msg_socket_cookie_) - + reinterpret_cast(&_impl_.inet_diag_msg_family_)) + sizeof(_impl_.inet_diag_msg_socket_cookie_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.inet_diag_msg_socket_next_hop_asn_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.mem_info_fmem_) - - reinterpret_cast(&_impl_.inet_diag_msg_socket_next_hop_asn_)) + sizeof(_impl_.mem_info_fmem_)); + ::memset(&_impl_.inet_diag_msg_socket_dest_asn_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.mem_info_wmem_) - + reinterpret_cast(&_impl_.inet_diag_msg_socket_dest_asn_)) + sizeof(_impl_.mem_info_wmem_)); } cached_has_bits = _impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.mem_info_tmem_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_send_scale_) - - reinterpret_cast(&_impl_.mem_info_tmem_)) + sizeof(_impl_.tcp_info_send_scale_)); + ::memset(&_impl_.mem_info_fmem_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_options_) - + reinterpret_cast(&_impl_.mem_info_fmem_)) + sizeof(_impl_.tcp_info_options_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_rcv_scale_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_unacked_) - - reinterpret_cast(&_impl_.tcp_info_rcv_scale_)) + sizeof(_impl_.tcp_info_unacked_)); + ::memset(&_impl_.tcp_info_send_scale_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_rcv_mss_) - + reinterpret_cast(&_impl_.tcp_info_send_scale_)) + sizeof(_impl_.tcp_info_rcv_mss_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_sacked_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_last_ack_recv_) - - reinterpret_cast(&_impl_.tcp_info_sacked_)) + sizeof(_impl_.tcp_info_last_ack_recv_)); + ::memset(&_impl_.tcp_info_unacked_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_last_data_recv_) - + reinterpret_cast(&_impl_.tcp_info_unacked_)) + sizeof(_impl_.tcp_info_last_data_recv_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_pmtu_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_reordering_) - - reinterpret_cast(&_impl_.tcp_info_pmtu_)) + sizeof(_impl_.tcp_info_reordering_)); + ::memset(&_impl_.tcp_info_last_ack_recv_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_adv_mss_) - + reinterpret_cast(&_impl_.tcp_info_last_ack_recv_)) + sizeof(_impl_.tcp_info_adv_mss_)); } cached_has_bits = _impl_._has_bits_[3]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.tcp_info_rcv_rtt_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_segs_out_) - - reinterpret_cast(&_impl_.tcp_info_rcv_rtt_)) + sizeof(_impl_.tcp_info_segs_out_)); + ::memset(&_impl_.tcp_info_reordering_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_bytes_received_) - + reinterpret_cast(&_impl_.tcp_info_reordering_)) + sizeof(_impl_.tcp_info_bytes_received_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_segs_in_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_rwnd_limited_) - - reinterpret_cast(&_impl_.tcp_info_segs_in_)) + sizeof(_impl_.tcp_info_rwnd_limited_)); + ::memset(&_impl_.tcp_info_segs_out_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_busy_time_) - + reinterpret_cast(&_impl_.tcp_info_segs_out_)) + sizeof(_impl_.tcp_info_busy_time_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_sndbuf_limited_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_rcv_ooopack_) - - reinterpret_cast(&_impl_.tcp_info_sndbuf_limited_)) + sizeof(_impl_.tcp_info_rcv_ooopack_)); + ::memset(&_impl_.tcp_info_rwnd_limited_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_reord_seen_) - + reinterpret_cast(&_impl_.tcp_info_rwnd_limited_)) + sizeof(_impl_.tcp_info_reord_seen_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_snd_wnd_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.type_of_service_) - - reinterpret_cast(&_impl_.tcp_info_snd_wnd_)) + sizeof(_impl_.type_of_service_)); + ::memset(&_impl_.tcp_info_rcv_ooopack_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.congestion_algorithm_enum_) - + reinterpret_cast(&_impl_.tcp_info_rcv_ooopack_)) + sizeof(_impl_.congestion_algorithm_enum_)); } cached_has_bits = _impl_._has_bits_[4]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.traffic_class_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.sk_mem_info_optmem_) - - reinterpret_cast(&_impl_.traffic_class_)) + sizeof(_impl_.sk_mem_info_optmem_)); + ::memset(&_impl_.type_of_service_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.sk_mem_info_wmem_queued_) - + reinterpret_cast(&_impl_.type_of_service_)) + sizeof(_impl_.sk_mem_info_wmem_queued_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.sk_mem_info_backlog_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.dctcp_info_enabled_) - - reinterpret_cast(&_impl_.sk_mem_info_backlog_)) + sizeof(_impl_.dctcp_info_enabled_)); + ::memset(&_impl_.sk_mem_info_optmem_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.vegas_info_min_rtt_) - + reinterpret_cast(&_impl_.sk_mem_info_optmem_)) + sizeof(_impl_.vegas_info_min_rtt_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.dctcp_info_ce_state_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.bbr_info_pacing_gain_) - - reinterpret_cast(&_impl_.dctcp_info_ce_state_)) + sizeof(_impl_.bbr_info_pacing_gain_)); + ::memset(&_impl_.dctcp_info_enabled_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.bbr_info_min_rtt_) - + reinterpret_cast(&_impl_.dctcp_info_enabled_)) + sizeof(_impl_.bbr_info_min_rtt_)); } - if (BatchCheckHasBit(cached_has_bits, 0x0f000000U)) { - ::memset(&_impl_.bbr_info_cwnd_gain_, 0, static_cast<::size_t>( + if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { + ::memset(&_impl_.bbr_info_pacing_gain_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.c_group_) - - reinterpret_cast(&_impl_.bbr_info_cwnd_gain_)) + sizeof(_impl_.c_group_)); + reinterpret_cast(&_impl_.bbr_info_pacing_gain_)) + sizeof(_impl_.c_group_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); @@ -2990,7 +3008,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_netlinker_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3040,7 +3058,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_uplink1_nic_pci_device() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3061,7 +3079,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_uplink1_nic_speed_mbps() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3162,7 +3180,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_uplink2_nic_pci_vendor() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3171,7 +3189,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_uplink2_nic_pci_device() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3192,7 +3210,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_uplink2_nic_speed_mbps() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3261,7 +3279,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_inet_diag_msg_family() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3270,7 +3288,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_inet_diag_msg_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3279,7 +3297,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_inet_diag_msg_timer() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3288,7 +3306,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_inet_diag_msg_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3297,7 +3315,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_inet_diag_msg_socket_source_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3306,7 +3324,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_inet_diag_msg_socket_destination_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3342,7 +3360,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_inet_diag_msg_socket_cookie() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3351,7 +3369,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_inet_diag_msg_socket_dest_asn() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3360,7 +3378,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_inet_diag_msg_socket_next_hop_asn() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3369,7 +3387,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_inet_diag_msg_expires() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3378,7 +3396,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_inet_diag_msg_rqueue() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3387,7 +3405,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_inet_diag_msg_wqueue() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3396,7 +3414,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_inet_diag_msg_uid() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3405,7 +3423,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_inet_diag_msg_inode() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3413,8 +3431,18 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; + if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (!this_._internal_inet_diag_msg_socket_dest_network_owner().empty()) { + const ::std::string& _s = this_._internal_inet_diag_msg_socket_dest_network_owner(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner"); + target = stream->WriteStringMaybeAliased(1018, _s, target); + } + } + // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_mem_info_rmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3423,7 +3451,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_mem_info_wmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3431,8 +3459,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_mem_info_fmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3440,9 +3469,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[2]; // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_mem_info_tmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3451,7 +3479,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3460,7 +3488,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_ca_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3469,7 +3497,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_retransmits() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3478,7 +3506,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_probes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3487,7 +3515,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_backoff() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3496,7 +3524,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_options() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3505,7 +3533,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_send_scale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3514,7 +3542,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_rcv_scale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3523,7 +3551,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3532,7 +3560,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_fast_open_client_failed() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3541,7 +3569,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3550,7 +3578,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_ato() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3559,7 +3587,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3568,7 +3596,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3577,7 +3605,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_unacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3586,7 +3614,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_sacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3595,7 +3623,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_lost() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3604,7 +3632,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3613,7 +3641,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_fackets() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3622,7 +3650,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3631,7 +3659,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3640,7 +3668,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3649,7 +3677,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3658,7 +3686,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3667,7 +3695,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3676,7 +3704,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3685,7 +3713,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rtt_var() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3694,7 +3722,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3703,7 +3731,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3712,7 +3740,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_adv_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3720,8 +3748,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[3]; // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_reordering() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3729,9 +3758,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[3]; // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3740,7 +3768,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_rcv_space() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3749,7 +3777,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_total_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3758,7 +3786,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_pacing_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3767,7 +3795,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_max_pacing_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3776,7 +3804,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3785,7 +3813,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_bytes_received() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3794,7 +3822,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3803,7 +3831,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3812,7 +3840,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_not_sent_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3821,7 +3849,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3830,7 +3858,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3839,7 +3867,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_data_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3848,7 +3876,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_delivery_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3857,7 +3885,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_busy_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3866,7 +3894,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rwnd_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3875,7 +3903,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_sndbuf_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3884,7 +3912,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_delivered() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3893,7 +3921,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_delivered_ce() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3902,7 +3930,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_bytes_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3911,7 +3939,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_bytes_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3920,7 +3948,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_dsack_dups() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3929,7 +3957,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3938,7 +3966,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3947,7 +3975,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3956,7 +3984,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3965,7 +3993,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rehash() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3974,7 +4002,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_total_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3983,7 +4011,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3992,7 +4020,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4002,7 +4030,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!this_._internal_congestion_algorithm_string().empty()) { const ::std::string& _s = this_._internal_congestion_algorithm_string(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( @@ -4013,7 +4041,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[3]; // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_congestion_algorithm_enum() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( @@ -4021,8 +4049,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[4]; // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_type_of_service() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4030,9 +4059,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[4]; // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_traffic_class() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4041,7 +4069,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4050,7 +4078,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_sk_mem_info_rcv_buf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4059,7 +4087,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4068,7 +4096,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_sk_mem_info_snd_buf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4077,7 +4105,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4086,7 +4114,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4095,7 +4123,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_optmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4104,7 +4132,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_sk_mem_info_backlog() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4113,7 +4141,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_drops() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4122,7 +4150,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_shutdown_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4131,7 +4159,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_vegas_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4140,7 +4168,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_vegas_info_rtt_cnt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4149,7 +4177,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_vegas_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4158,7 +4186,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_vegas_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4167,7 +4195,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_dctcp_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4176,7 +4204,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4185,7 +4213,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_dctcp_info_alpha() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4194,7 +4222,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4203,7 +4231,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4212,7 +4240,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4221,7 +4249,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4230,7 +4258,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4239,7 +4267,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4248,7 +4276,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4257,7 +4285,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_class_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4266,7 +4294,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_sock_opt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4275,7 +4303,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 c_group = 2103 [json_name = "cGroup"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_c_group() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -4600,844 +4628,851 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; + // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (!this_._internal_inet_diag_msg_socket_dest_network_owner().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_inet_diag_msg_socket_dest_network_owner()); + } + } + // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!this_._internal_congestion_algorithm_string().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( this_._internal_congestion_algorithm_string()); } } // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_netlinker_id() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_netlinker_id()); } } // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_uplink1_nic_pci_device() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink1_nic_pci_device()); } } // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_uplink1_nic_speed_mbps() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink1_nic_speed_mbps()); } } // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_uplink2_nic_pci_vendor() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_pci_vendor()); } } // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_uplink2_nic_pci_device() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_pci_device()); } } // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_uplink2_nic_speed_mbps() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_speed_mbps()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_inet_diag_msg_family() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_family()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_inet_diag_msg_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_state()); } } // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_inet_diag_msg_timer() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_timer()); } } // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_inet_diag_msg_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_retrans()); } } // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_inet_diag_msg_socket_source_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_socket_source_port()); } } // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_inet_diag_msg_socket_destination_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_socket_destination_port()); } } // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_inet_diag_msg_expires() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_expires()); } } // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_inet_diag_msg_socket_cookie() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_inet_diag_msg_socket_cookie()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_inet_diag_msg_socket_dest_asn() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_inet_diag_msg_socket_dest_asn()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_inet_diag_msg_socket_next_hop_asn() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_inet_diag_msg_socket_next_hop_asn()); } } // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_inet_diag_msg_rqueue() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_rqueue()); } } // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_inet_diag_msg_wqueue() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_wqueue()); } } // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_inet_diag_msg_uid() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_uid()); } } // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_inet_diag_msg_inode() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_inode()); } } // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_mem_info_rmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_rmem()); } } // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_mem_info_wmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_wmem()); } } + } + cached_has_bits = this_._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_mem_info_fmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_fmem()); } } - } - cached_has_bits = this_._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_mem_info_tmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_tmem()); } } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_state()); } } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_ca_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ca_state()); } } // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_retransmits() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retransmits()); } } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_probes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_probes()); } } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_backoff() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_backoff()); } } // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_options() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_options()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_send_scale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_send_scale()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_rcv_scale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_scale()); } } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivery_rate_app_limited()); } } // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_fast_open_client_failed() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_fast_open_client_failed()); } } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rto()); } } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_ato() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ato()); } } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_mss()); } } // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_mss()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_unacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_unacked()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_sacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_sacked()); } } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_lost() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_lost()); } } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retrans()); } } // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_fackets() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_fackets()); } } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_sent()); } } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_sent()); } } // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_recv()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_recv()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_pmtu()); } } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ssthresh()); } } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rtt()); } } // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rtt_var() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rtt_var()); } } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_ssthresh()); } } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_cwnd()); } } // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_adv_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_adv_mss()); } } + } + cached_has_bits = this_._impl_._has_bits_[3]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_reordering() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reordering()); } } - } - cached_has_bits = this_._impl_._has_bits_[3]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_rtt()); } } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_rcv_space() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_space()); } } // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_total_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_retrans()); } } // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_pacing_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_pacing_rate()); } } // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_max_pacing_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_max_pacing_rate()); } } // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_acked()); } } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_bytes_received() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_received()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_segs_out() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_segs_out()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_segs_in()); } } // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_not_sent_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_not_sent_bytes()); } } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_min_rtt()); } } // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_data_segs_in()); } } // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_data_segs_out() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_data_segs_out()); } } // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_delivery_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_delivery_rate()); } } // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_busy_time() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_busy_time()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rwnd_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_rwnd_limited()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_sndbuf_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_sndbuf_limited()); } } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_delivered() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivered()); } } // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_delivered_ce() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivered_ce()); } } // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_bytes_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_sent()); } } // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_bytes_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_retrans()); } } // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_dsack_dups() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_dsack_dups()); } } // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reord_seen()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ooopack()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_wnd()); } } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_wnd()); } } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rehash() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rehash()); } } // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_total_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto()); } } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_recoveries()); } } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_time()); } } // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_congestion_algorithm_enum() != 0) { total_size += 2 + ::_pbi::WireFormatLite::EnumSize(this_._internal_congestion_algorithm_enum()); } } + } + cached_has_bits = this_._impl_._has_bits_[4]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_type_of_service() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_type_of_service()); } } - } - cached_has_bits = this_._impl_._has_bits_[4]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_traffic_class() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_traffic_class()); } } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_rmem_alloc()); } } // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_sk_mem_info_rcv_buf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_rcv_buf()); } } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_alloc()); } } // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_sk_mem_info_snd_buf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_snd_buf()); } } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_fwd_alloc()); } } // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_queued()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_optmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_optmem()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_sk_mem_info_backlog() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_backlog()); } } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_drops() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_drops()); } } // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_shutdown_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_shutdown_state()); } } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_vegas_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_enabled()); } } // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_vegas_info_rtt_cnt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_rtt_cnt()); } } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_vegas_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_rtt()); } } // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_vegas_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_min_rtt()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_dctcp_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_enabled()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ce_state()); } } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_dctcp_info_alpha() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_alpha()); } } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_ecn()); } } // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_tot()); } } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_lo()); } } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_hi()); } } // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_min_rtt()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_pacing_gain()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0f000000U)) { // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_cwnd_gain()); } } // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_class_id() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_class_id()); } } // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_sock_opt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sock_opt()); } } // uint64 c_group = 2103 [json_name = "cGroup"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_c_group() != 0) { total_size += 3 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_c_group()); @@ -5802,6 +5837,15 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (!from._internal_inet_diag_msg_socket_dest_network_owner().empty()) { + _this->_internal_set_inet_diag_msg_socket_dest_network_owner(from._internal_inet_diag_msg_socket_dest_network_owner()); + } else { + if (_this->_impl_.inet_diag_msg_socket_dest_network_owner_.IsDefault()) { + _this->_internal_set_inet_diag_msg_socket_dest_network_owner(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!from._internal_congestion_algorithm_string().empty()) { _this->_internal_set_congestion_algorithm_string(from._internal_congestion_algorithm_string()); } else { @@ -5810,608 +5854,608 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_netlinker_id() != 0) { _this->_impl_.netlinker_id_ = from._impl_.netlinker_id_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_uplink1_nic_pci_device() != 0) { _this->_impl_.uplink1_nic_pci_device_ = from._impl_.uplink1_nic_pci_device_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_uplink1_nic_speed_mbps() != 0) { _this->_impl_.uplink1_nic_speed_mbps_ = from._impl_.uplink1_nic_speed_mbps_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_uplink2_nic_pci_vendor() != 0) { _this->_impl_.uplink2_nic_pci_vendor_ = from._impl_.uplink2_nic_pci_vendor_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_uplink2_nic_pci_device() != 0) { _this->_impl_.uplink2_nic_pci_device_ = from._impl_.uplink2_nic_pci_device_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_uplink2_nic_speed_mbps() != 0) { _this->_impl_.uplink2_nic_speed_mbps_ = from._impl_.uplink2_nic_speed_mbps_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_inet_diag_msg_family() != 0) { _this->_impl_.inet_diag_msg_family_ = from._impl_.inet_diag_msg_family_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_inet_diag_msg_state() != 0) { _this->_impl_.inet_diag_msg_state_ = from._impl_.inet_diag_msg_state_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_inet_diag_msg_timer() != 0) { _this->_impl_.inet_diag_msg_timer_ = from._impl_.inet_diag_msg_timer_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_inet_diag_msg_retrans() != 0) { _this->_impl_.inet_diag_msg_retrans_ = from._impl_.inet_diag_msg_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_inet_diag_msg_socket_source_port() != 0) { _this->_impl_.inet_diag_msg_socket_source_port_ = from._impl_.inet_diag_msg_socket_source_port_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_inet_diag_msg_socket_destination_port() != 0) { _this->_impl_.inet_diag_msg_socket_destination_port_ = from._impl_.inet_diag_msg_socket_destination_port_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_inet_diag_msg_expires() != 0) { _this->_impl_.inet_diag_msg_expires_ = from._impl_.inet_diag_msg_expires_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_inet_diag_msg_socket_cookie() != 0) { _this->_impl_.inet_diag_msg_socket_cookie_ = from._impl_.inet_diag_msg_socket_cookie_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_inet_diag_msg_socket_dest_asn() != 0) { _this->_impl_.inet_diag_msg_socket_dest_asn_ = from._impl_.inet_diag_msg_socket_dest_asn_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_inet_diag_msg_socket_next_hop_asn() != 0) { _this->_impl_.inet_diag_msg_socket_next_hop_asn_ = from._impl_.inet_diag_msg_socket_next_hop_asn_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_inet_diag_msg_rqueue() != 0) { _this->_impl_.inet_diag_msg_rqueue_ = from._impl_.inet_diag_msg_rqueue_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_inet_diag_msg_wqueue() != 0) { _this->_impl_.inet_diag_msg_wqueue_ = from._impl_.inet_diag_msg_wqueue_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_inet_diag_msg_uid() != 0) { _this->_impl_.inet_diag_msg_uid_ = from._impl_.inet_diag_msg_uid_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_inet_diag_msg_inode() != 0) { _this->_impl_.inet_diag_msg_inode_ = from._impl_.inet_diag_msg_inode_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_mem_info_rmem() != 0) { _this->_impl_.mem_info_rmem_ = from._impl_.mem_info_rmem_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_mem_info_wmem() != 0) { _this->_impl_.mem_info_wmem_ = from._impl_.mem_info_wmem_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_mem_info_fmem() != 0) { - _this->_impl_.mem_info_fmem_ = from._impl_.mem_info_fmem_; - } - } } cached_has_bits = from._impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_mem_info_fmem() != 0) { + _this->_impl_.mem_info_fmem_ = from._impl_.mem_info_fmem_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_mem_info_tmem() != 0) { _this->_impl_.mem_info_tmem_ = from._impl_.mem_info_tmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_tcp_info_state() != 0) { _this->_impl_.tcp_info_state_ = from._impl_.tcp_info_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_tcp_info_ca_state() != 0) { _this->_impl_.tcp_info_ca_state_ = from._impl_.tcp_info_ca_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_tcp_info_retransmits() != 0) { _this->_impl_.tcp_info_retransmits_ = from._impl_.tcp_info_retransmits_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_tcp_info_probes() != 0) { _this->_impl_.tcp_info_probes_ = from._impl_.tcp_info_probes_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_tcp_info_backoff() != 0) { _this->_impl_.tcp_info_backoff_ = from._impl_.tcp_info_backoff_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_tcp_info_options() != 0) { _this->_impl_.tcp_info_options_ = from._impl_.tcp_info_options_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_tcp_info_send_scale() != 0) { _this->_impl_.tcp_info_send_scale_ = from._impl_.tcp_info_send_scale_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_tcp_info_rcv_scale() != 0) { _this->_impl_.tcp_info_rcv_scale_ = from._impl_.tcp_info_rcv_scale_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_delivery_rate_app_limited() != 0) { _this->_impl_.tcp_info_delivery_rate_app_limited_ = from._impl_.tcp_info_delivery_rate_app_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_fast_open_client_failed() != 0) { _this->_impl_.tcp_info_fast_open_client_failed_ = from._impl_.tcp_info_fast_open_client_failed_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_tcp_info_rto() != 0) { _this->_impl_.tcp_info_rto_ = from._impl_.tcp_info_rto_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_tcp_info_ato() != 0) { _this->_impl_.tcp_info_ato_ = from._impl_.tcp_info_ato_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_tcp_info_snd_mss() != 0) { _this->_impl_.tcp_info_snd_mss_ = from._impl_.tcp_info_snd_mss_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_tcp_info_rcv_mss() != 0) { _this->_impl_.tcp_info_rcv_mss_ = from._impl_.tcp_info_rcv_mss_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_tcp_info_unacked() != 0) { _this->_impl_.tcp_info_unacked_ = from._impl_.tcp_info_unacked_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_tcp_info_sacked() != 0) { _this->_impl_.tcp_info_sacked_ = from._impl_.tcp_info_sacked_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_tcp_info_lost() != 0) { _this->_impl_.tcp_info_lost_ = from._impl_.tcp_info_lost_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_tcp_info_retrans() != 0) { _this->_impl_.tcp_info_retrans_ = from._impl_.tcp_info_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_tcp_info_fackets() != 0) { _this->_impl_.tcp_info_fackets_ = from._impl_.tcp_info_fackets_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_tcp_info_last_data_sent() != 0) { _this->_impl_.tcp_info_last_data_sent_ = from._impl_.tcp_info_last_data_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_tcp_info_last_ack_sent() != 0) { _this->_impl_.tcp_info_last_ack_sent_ = from._impl_.tcp_info_last_ack_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_tcp_info_last_data_recv() != 0) { _this->_impl_.tcp_info_last_data_recv_ = from._impl_.tcp_info_last_data_recv_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_tcp_info_last_ack_recv() != 0) { _this->_impl_.tcp_info_last_ack_recv_ = from._impl_.tcp_info_last_ack_recv_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_pmtu() != 0) { _this->_impl_.tcp_info_pmtu_ = from._impl_.tcp_info_pmtu_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_rcv_ssthresh() != 0) { _this->_impl_.tcp_info_rcv_ssthresh_ = from._impl_.tcp_info_rcv_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_rtt() != 0) { _this->_impl_.tcp_info_rtt_ = from._impl_.tcp_info_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_rtt_var() != 0) { _this->_impl_.tcp_info_rtt_var_ = from._impl_.tcp_info_rtt_var_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_snd_ssthresh() != 0) { _this->_impl_.tcp_info_snd_ssthresh_ = from._impl_.tcp_info_snd_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_snd_cwnd() != 0) { _this->_impl_.tcp_info_snd_cwnd_ = from._impl_.tcp_info_snd_cwnd_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_tcp_info_adv_mss() != 0) { _this->_impl_.tcp_info_adv_mss_ = from._impl_.tcp_info_adv_mss_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_tcp_info_reordering() != 0) { - _this->_impl_.tcp_info_reordering_ = from._impl_.tcp_info_reordering_; - } - } } cached_has_bits = from._impl_._has_bits_[3]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_tcp_info_reordering() != 0) { + _this->_impl_.tcp_info_reordering_ = from._impl_.tcp_info_reordering_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_tcp_info_rcv_rtt() != 0) { _this->_impl_.tcp_info_rcv_rtt_ = from._impl_.tcp_info_rcv_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_tcp_info_rcv_space() != 0) { _this->_impl_.tcp_info_rcv_space_ = from._impl_.tcp_info_rcv_space_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_tcp_info_total_retrans() != 0) { _this->_impl_.tcp_info_total_retrans_ = from._impl_.tcp_info_total_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_tcp_info_pacing_rate() != 0) { _this->_impl_.tcp_info_pacing_rate_ = from._impl_.tcp_info_pacing_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_tcp_info_max_pacing_rate() != 0) { _this->_impl_.tcp_info_max_pacing_rate_ = from._impl_.tcp_info_max_pacing_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_tcp_info_bytes_acked() != 0) { _this->_impl_.tcp_info_bytes_acked_ = from._impl_.tcp_info_bytes_acked_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_tcp_info_bytes_received() != 0) { _this->_impl_.tcp_info_bytes_received_ = from._impl_.tcp_info_bytes_received_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_tcp_info_segs_out() != 0) { _this->_impl_.tcp_info_segs_out_ = from._impl_.tcp_info_segs_out_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_tcp_info_segs_in() != 0) { _this->_impl_.tcp_info_segs_in_ = from._impl_.tcp_info_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_not_sent_bytes() != 0) { _this->_impl_.tcp_info_not_sent_bytes_ = from._impl_.tcp_info_not_sent_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_min_rtt() != 0) { _this->_impl_.tcp_info_min_rtt_ = from._impl_.tcp_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_tcp_info_data_segs_in() != 0) { _this->_impl_.tcp_info_data_segs_in_ = from._impl_.tcp_info_data_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_tcp_info_data_segs_out() != 0) { _this->_impl_.tcp_info_data_segs_out_ = from._impl_.tcp_info_data_segs_out_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_tcp_info_delivery_rate() != 0) { _this->_impl_.tcp_info_delivery_rate_ = from._impl_.tcp_info_delivery_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_tcp_info_busy_time() != 0) { _this->_impl_.tcp_info_busy_time_ = from._impl_.tcp_info_busy_time_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_tcp_info_rwnd_limited() != 0) { _this->_impl_.tcp_info_rwnd_limited_ = from._impl_.tcp_info_rwnd_limited_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_tcp_info_sndbuf_limited() != 0) { _this->_impl_.tcp_info_sndbuf_limited_ = from._impl_.tcp_info_sndbuf_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_tcp_info_delivered() != 0) { _this->_impl_.tcp_info_delivered_ = from._impl_.tcp_info_delivered_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_tcp_info_delivered_ce() != 0) { _this->_impl_.tcp_info_delivered_ce_ = from._impl_.tcp_info_delivered_ce_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_tcp_info_bytes_sent() != 0) { _this->_impl_.tcp_info_bytes_sent_ = from._impl_.tcp_info_bytes_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_tcp_info_bytes_retrans() != 0) { _this->_impl_.tcp_info_bytes_retrans_ = from._impl_.tcp_info_bytes_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_tcp_info_dsack_dups() != 0) { _this->_impl_.tcp_info_dsack_dups_ = from._impl_.tcp_info_dsack_dups_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_tcp_info_reord_seen() != 0) { _this->_impl_.tcp_info_reord_seen_ = from._impl_.tcp_info_reord_seen_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_tcp_info_rcv_ooopack() != 0) { _this->_impl_.tcp_info_rcv_ooopack_ = from._impl_.tcp_info_rcv_ooopack_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_snd_wnd() != 0) { _this->_impl_.tcp_info_snd_wnd_ = from._impl_.tcp_info_snd_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_rcv_wnd() != 0) { _this->_impl_.tcp_info_rcv_wnd_ = from._impl_.tcp_info_rcv_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_rehash() != 0) { _this->_impl_.tcp_info_rehash_ = from._impl_.tcp_info_rehash_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_total_rto() != 0) { _this->_impl_.tcp_info_total_rto_ = from._impl_.tcp_info_total_rto_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_total_rto_recoveries() != 0) { _this->_impl_.tcp_info_total_rto_recoveries_ = from._impl_.tcp_info_total_rto_recoveries_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_total_rto_time() != 0) { _this->_impl_.tcp_info_total_rto_time_ = from._impl_.tcp_info_total_rto_time_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_congestion_algorithm_enum() != 0) { _this->_impl_.congestion_algorithm_enum_ = from._impl_.congestion_algorithm_enum_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_type_of_service() != 0) { - _this->_impl_.type_of_service_ = from._impl_.type_of_service_; - } - } } cached_has_bits = from._impl_._has_bits_[4]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_type_of_service() != 0) { + _this->_impl_.type_of_service_ = from._impl_.type_of_service_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_traffic_class() != 0) { _this->_impl_.traffic_class_ = from._impl_.traffic_class_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_sk_mem_info_rmem_alloc() != 0) { _this->_impl_.sk_mem_info_rmem_alloc_ = from._impl_.sk_mem_info_rmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_sk_mem_info_rcv_buf() != 0) { _this->_impl_.sk_mem_info_rcv_buf_ = from._impl_.sk_mem_info_rcv_buf_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_sk_mem_info_wmem_alloc() != 0) { _this->_impl_.sk_mem_info_wmem_alloc_ = from._impl_.sk_mem_info_wmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_sk_mem_info_snd_buf() != 0) { _this->_impl_.sk_mem_info_snd_buf_ = from._impl_.sk_mem_info_snd_buf_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_sk_mem_info_fwd_alloc() != 0) { _this->_impl_.sk_mem_info_fwd_alloc_ = from._impl_.sk_mem_info_fwd_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_sk_mem_info_wmem_queued() != 0) { _this->_impl_.sk_mem_info_wmem_queued_ = from._impl_.sk_mem_info_wmem_queued_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_sk_mem_info_optmem() != 0) { _this->_impl_.sk_mem_info_optmem_ = from._impl_.sk_mem_info_optmem_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_sk_mem_info_backlog() != 0) { _this->_impl_.sk_mem_info_backlog_ = from._impl_.sk_mem_info_backlog_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_sk_mem_info_drops() != 0) { _this->_impl_.sk_mem_info_drops_ = from._impl_.sk_mem_info_drops_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_shutdown_state() != 0) { _this->_impl_.shutdown_state_ = from._impl_.shutdown_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_vegas_info_enabled() != 0) { _this->_impl_.vegas_info_enabled_ = from._impl_.vegas_info_enabled_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_vegas_info_rtt_cnt() != 0) { _this->_impl_.vegas_info_rtt_cnt_ = from._impl_.vegas_info_rtt_cnt_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_vegas_info_rtt() != 0) { _this->_impl_.vegas_info_rtt_ = from._impl_.vegas_info_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_vegas_info_min_rtt() != 0) { _this->_impl_.vegas_info_min_rtt_ = from._impl_.vegas_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_dctcp_info_enabled() != 0) { _this->_impl_.dctcp_info_enabled_ = from._impl_.dctcp_info_enabled_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_dctcp_info_ce_state() != 0) { _this->_impl_.dctcp_info_ce_state_ = from._impl_.dctcp_info_ce_state_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_dctcp_info_alpha() != 0) { _this->_impl_.dctcp_info_alpha_ = from._impl_.dctcp_info_alpha_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_dctcp_info_ab_ecn() != 0) { _this->_impl_.dctcp_info_ab_ecn_ = from._impl_.dctcp_info_ab_ecn_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_dctcp_info_ab_tot() != 0) { _this->_impl_.dctcp_info_ab_tot_ = from._impl_.dctcp_info_ab_tot_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_bbr_info_bw_lo() != 0) { _this->_impl_.bbr_info_bw_lo_ = from._impl_.bbr_info_bw_lo_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_bbr_info_bw_hi() != 0) { _this->_impl_.bbr_info_bw_hi_ = from._impl_.bbr_info_bw_hi_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_bbr_info_min_rtt() != 0) { _this->_impl_.bbr_info_min_rtt_ = from._impl_.bbr_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_bbr_info_pacing_gain() != 0) { _this->_impl_.bbr_info_pacing_gain_ = from._impl_.bbr_info_pacing_gain_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0f000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_bbr_info_cwnd_gain() != 0) { _this->_impl_.bbr_info_cwnd_gain_ = from._impl_.bbr_info_cwnd_gain_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_class_id() != 0) { _this->_impl_.class_id_ = from._impl_.class_id_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_sock_opt() != 0) { _this->_impl_.sock_opt_ = from._impl_.sock_opt_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_c_group() != 0) { _this->_impl_.c_group_ = from._impl_.c_group_; } @@ -6478,6 +6522,7 @@ void XtcpFlatRecord::InternalSwap(XtcpFlatRecord* PROTOBUF_RESTRICT PROTOBUF_NON ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uplink2_lldp_port_descr_, &other->_impl_.uplink2_lldp_port_descr_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_source_, &other->_impl_.inet_diag_msg_socket_source_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_destination_, &other->_impl_.inet_diag_msg_socket_destination_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_dest_network_owner_, &other->_impl_.inet_diag_msg_socket_dest_network_owner_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.congestion_algorithm_string_, &other->_impl_.congestion_algorithm_string_, arena); ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_) diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h index fc373f9..43f7c1e 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h @@ -387,6 +387,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kUplink2LldpPortDescrFieldNumber = 224, kInetDiagMsgSocketSourceFieldNumber = 1007, kInetDiagMsgSocketDestinationFieldNumber = 1008, + kInetDiagMsgSocketDestNetworkOwnerFieldNumber = 1018, kCongestionAlgorithmStringFieldNumber = 1300, kNetlinkerIdFieldNumber = 62, kUplink1NicPciDeviceFieldNumber = 104, @@ -1063,6 +1064,21 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo PROTOBUF_ALWAYS_INLINE void _internal_set_inet_diag_msg_socket_destination(const ::std::string& value); ::std::string* PROTOBUF_NONNULL _internal_mutable_inet_diag_msg_socket_destination(); + public: + // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; + void clear_inet_diag_msg_socket_dest_network_owner() ; + [[nodiscard]] const ::std::string& inet_diag_msg_socket_dest_network_owner() const; + template + void set_inet_diag_msg_socket_dest_network_owner(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_inet_diag_msg_socket_dest_network_owner(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_inet_diag_msg_socket_dest_network_owner(); + void set_allocated_inet_diag_msg_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_inet_diag_msg_socket_dest_network_owner() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_inet_diag_msg_socket_dest_network_owner(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_inet_diag_msg_socket_dest_network_owner(); + public: // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; void clear_congestion_algorithm_string() ; @@ -2233,8 +2249,8 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo private: class _Internal; using ParseTableT_ = - ::google::protobuf::internal::TcParseTable<5, 156, - 0, 727, + ::google::protobuf::internal::TcParseTable<5, 157, + 0, 766, 103>; static constexpr ParseTableT_ InternalGenerateParseTable_( const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data); @@ -2302,6 +2318,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::google::protobuf::internal::ArenaStringPtr uplink2_lldp_port_descr_; ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_source_; ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_destination_; + ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_dest_network_owner_; ::google::protobuf::internal::ArenaStringPtr congestion_algorithm_string_; ::uint64_t netlinker_id_; ::uint32_t uplink1_nic_pci_device_; @@ -4189,7 +4206,7 @@ inline void XtcpFlatRecord::_internal_set_socket_fd(::uint64_t value) { inline void XtcpFlatRecord::clear_netlinker_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.netlinker_id_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } inline ::uint64_t XtcpFlatRecord::netlinker_id() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.netlinker_id) @@ -4197,7 +4214,7 @@ inline ::uint64_t XtcpFlatRecord::netlinker_id() const { } inline void XtcpFlatRecord::set_netlinker_id(::uint64_t value) { _internal_set_netlinker_id(value); - SetHasBit(_impl_._has_bits_[1], 0x00000200U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.netlinker_id) } inline ::uint64_t XtcpFlatRecord::_internal_netlinker_id() const { @@ -4429,7 +4446,7 @@ inline void XtcpFlatRecord::_internal_set_uplink1_nic_pci_vendor(::uint32_t valu inline void XtcpFlatRecord::clear_uplink1_nic_pci_device() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink1_nic_pci_device_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_device() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_device) @@ -4437,7 +4454,7 @@ inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_device() const { } inline void XtcpFlatRecord::set_uplink1_nic_pci_device(::uint32_t value) { _internal_set_uplink1_nic_pci_device(value); - SetHasBit(_impl_._has_bits_[1], 0x00000400U); + SetHasBit(_impl_._has_bits_[1], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_device) } inline ::uint32_t XtcpFlatRecord::_internal_uplink1_nic_pci_device() const { @@ -4517,7 +4534,7 @@ inline void XtcpFlatRecord::set_allocated_uplink1_nic_bus_info(::std::string* PR inline void XtcpFlatRecord::clear_uplink1_nic_speed_mbps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink1_nic_speed_mbps_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::uplink1_nic_speed_mbps() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_speed_mbps) @@ -4525,7 +4542,7 @@ inline ::uint32_t XtcpFlatRecord::uplink1_nic_speed_mbps() const { } inline void XtcpFlatRecord::set_uplink1_nic_speed_mbps(::uint32_t value) { _internal_set_uplink1_nic_speed_mbps(value); - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_speed_mbps) } inline ::uint32_t XtcpFlatRecord::_internal_uplink1_nic_speed_mbps() const { @@ -5117,7 +5134,7 @@ inline void XtcpFlatRecord::set_allocated_uplink2_nic_model(::std::string* PROTO inline void XtcpFlatRecord::clear_uplink2_nic_pci_vendor() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_pci_vendor_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_vendor() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_vendor) @@ -5125,7 +5142,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_vendor() const { } inline void XtcpFlatRecord::set_uplink2_nic_pci_vendor(::uint32_t value) { _internal_set_uplink2_nic_pci_vendor(value); - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_vendor) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_pci_vendor() const { @@ -5141,7 +5158,7 @@ inline void XtcpFlatRecord::_internal_set_uplink2_nic_pci_vendor(::uint32_t valu inline void XtcpFlatRecord::clear_uplink2_nic_pci_device() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_pci_device_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_device() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_device) @@ -5149,7 +5166,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_device() const { } inline void XtcpFlatRecord::set_uplink2_nic_pci_device(::uint32_t value) { _internal_set_uplink2_nic_pci_device(value); - SetHasBit(_impl_._has_bits_[1], 0x00002000U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_device) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_pci_device() const { @@ -5229,7 +5246,7 @@ inline void XtcpFlatRecord::set_allocated_uplink2_nic_bus_info(::std::string* PR inline void XtcpFlatRecord::clear_uplink2_nic_speed_mbps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_speed_mbps_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_speed_mbps() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_speed_mbps) @@ -5237,7 +5254,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_speed_mbps() const { } inline void XtcpFlatRecord::set_uplink2_nic_speed_mbps(::uint32_t value) { _internal_set_uplink2_nic_speed_mbps(value); - SetHasBit(_impl_._has_bits_[1], 0x00004000U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_speed_mbps) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_speed_mbps() const { @@ -5637,7 +5654,7 @@ inline void XtcpFlatRecord::set_allocated_uplink2_lldp_port_descr(::std::string* inline void XtcpFlatRecord::clear_inet_diag_msg_family() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_family_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00008000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_family() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) @@ -5645,7 +5662,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_family() const { } inline void XtcpFlatRecord::set_inet_diag_msg_family(::uint32_t value) { _internal_set_inet_diag_msg_family(value); - SetHasBit(_impl_._has_bits_[1], 0x00008000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_family() const { @@ -5661,7 +5678,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_family(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_state_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00010000U); + ClearHasBit(_impl_._has_bits_[1], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) @@ -5669,7 +5686,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_state() const { } inline void XtcpFlatRecord::set_inet_diag_msg_state(::uint32_t value) { _internal_set_inet_diag_msg_state(value); - SetHasBit(_impl_._has_bits_[1], 0x00010000U); + SetHasBit(_impl_._has_bits_[1], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_state() const { @@ -5685,7 +5702,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_state(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_timer() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_timer_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00020000U); + ClearHasBit(_impl_._has_bits_[1], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_timer() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) @@ -5693,7 +5710,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_timer() const { } inline void XtcpFlatRecord::set_inet_diag_msg_timer(::uint32_t value) { _internal_set_inet_diag_msg_timer(value); - SetHasBit(_impl_._has_bits_[1], 0x00020000U); + SetHasBit(_impl_._has_bits_[1], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_timer() const { @@ -5709,7 +5726,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_timer(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00040000U); + ClearHasBit(_impl_._has_bits_[1], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) @@ -5717,7 +5734,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_retrans() const { } inline void XtcpFlatRecord::set_inet_diag_msg_retrans(::uint32_t value) { _internal_set_inet_diag_msg_retrans(value); - SetHasBit(_impl_._has_bits_[1], 0x00040000U); + SetHasBit(_impl_._has_bits_[1], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_retrans() const { @@ -5733,7 +5750,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_retrans(::uint32_t value inline void XtcpFlatRecord::clear_inet_diag_msg_socket_source_port() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_source_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00080000U); + ClearHasBit(_impl_._has_bits_[1], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_source_port() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) @@ -5741,7 +5758,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_source_port() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_source_port(::uint32_t value) { _internal_set_inet_diag_msg_socket_source_port(value); - SetHasBit(_impl_._has_bits_[1], 0x00080000U); + SetHasBit(_impl_._has_bits_[1], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_source_port() const { @@ -5757,7 +5774,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_source_port(::uin inline void XtcpFlatRecord::clear_inet_diag_msg_socket_destination_port() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_destination_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00100000U); + ClearHasBit(_impl_._has_bits_[1], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_destination_port() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) @@ -5765,7 +5782,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_destination_port() const } inline void XtcpFlatRecord::set_inet_diag_msg_socket_destination_port(::uint32_t value) { _internal_set_inet_diag_msg_socket_destination_port(value); - SetHasBit(_impl_._has_bits_[1], 0x00100000U); + SetHasBit(_impl_._has_bits_[1], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_destination_port() const { @@ -5933,7 +5950,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_interface(::uint3 inline void XtcpFlatRecord::clear_inet_diag_msg_socket_cookie() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_cookie_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00400000U); + ClearHasBit(_impl_._has_bits_[1], 0x00800000U); } inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_cookie() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_cookie) @@ -5941,7 +5958,7 @@ inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_cookie() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_cookie(::uint64_t value) { _internal_set_inet_diag_msg_socket_cookie(value); - SetHasBit(_impl_._has_bits_[1], 0x00400000U); + SetHasBit(_impl_._has_bits_[1], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_cookie) } inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_cookie() const { @@ -5957,7 +5974,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_cookie(::uint64_t inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_asn() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_dest_asn_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00800000U); + ClearHasBit(_impl_._has_bits_[1], 0x01000000U); } inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_dest_asn() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_asn) @@ -5965,7 +5982,7 @@ inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_dest_asn() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_dest_asn(::uint64_t value) { _internal_set_inet_diag_msg_socket_dest_asn(value); - SetHasBit(_impl_._has_bits_[1], 0x00800000U); + SetHasBit(_impl_._has_bits_[1], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_asn) } inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_asn() const { @@ -5981,7 +5998,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_asn(::uint64 inline void XtcpFlatRecord::clear_inet_diag_msg_socket_next_hop_asn() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_next_hop_asn_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x01000000U); + ClearHasBit(_impl_._has_bits_[1], 0x02000000U); } inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_next_hop_asn() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_next_hop_asn) @@ -5989,7 +6006,7 @@ inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_next_hop_asn() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_next_hop_asn(::uint64_t value) { _internal_set_inet_diag_msg_socket_next_hop_asn(value); - SetHasBit(_impl_._has_bits_[1], 0x01000000U); + SetHasBit(_impl_._has_bits_[1], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_next_hop_asn) } inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_next_hop_asn() const { @@ -6005,7 +6022,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_next_hop_asn(::ui inline void XtcpFlatRecord::clear_inet_diag_msg_expires() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_expires_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00200000U); + ClearHasBit(_impl_._has_bits_[1], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_expires() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_expires) @@ -6013,7 +6030,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_expires() const { } inline void XtcpFlatRecord::set_inet_diag_msg_expires(::uint32_t value) { _internal_set_inet_diag_msg_expires(value); - SetHasBit(_impl_._has_bits_[1], 0x00200000U); + SetHasBit(_impl_._has_bits_[1], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_expires) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_expires() const { @@ -6029,7 +6046,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_expires(::uint32_t value inline void XtcpFlatRecord::clear_inet_diag_msg_rqueue() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_rqueue_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x02000000U); + ClearHasBit(_impl_._has_bits_[1], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_rqueue() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_rqueue) @@ -6037,7 +6054,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_rqueue() const { } inline void XtcpFlatRecord::set_inet_diag_msg_rqueue(::uint32_t value) { _internal_set_inet_diag_msg_rqueue(value); - SetHasBit(_impl_._has_bits_[1], 0x02000000U); + SetHasBit(_impl_._has_bits_[1], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_rqueue) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_rqueue() const { @@ -6053,7 +6070,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_rqueue(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_wqueue() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_wqueue_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x04000000U); + ClearHasBit(_impl_._has_bits_[1], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_wqueue() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_wqueue) @@ -6061,7 +6078,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_wqueue() const { } inline void XtcpFlatRecord::set_inet_diag_msg_wqueue(::uint32_t value) { _internal_set_inet_diag_msg_wqueue(value); - SetHasBit(_impl_._has_bits_[1], 0x04000000U); + SetHasBit(_impl_._has_bits_[1], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_wqueue) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_wqueue() const { @@ -6077,7 +6094,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_wqueue(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_uid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_uid_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x08000000U); + ClearHasBit(_impl_._has_bits_[1], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_uid() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_uid) @@ -6085,7 +6102,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_uid() const { } inline void XtcpFlatRecord::set_inet_diag_msg_uid(::uint32_t value) { _internal_set_inet_diag_msg_uid(value); - SetHasBit(_impl_._has_bits_[1], 0x08000000U); + SetHasBit(_impl_._has_bits_[1], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_uid) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_uid() const { @@ -6101,7 +6118,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_uid(::uint32_t value) { inline void XtcpFlatRecord::clear_inet_diag_msg_inode() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_inode_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x10000000U); + ClearHasBit(_impl_._has_bits_[1], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_inode() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_inode) @@ -6109,7 +6126,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_inode() const { } inline void XtcpFlatRecord::set_inet_diag_msg_inode(::uint32_t value) { _internal_set_inet_diag_msg_inode(value); - SetHasBit(_impl_._has_bits_[1], 0x10000000U); + SetHasBit(_impl_._has_bits_[1], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_inode) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_inode() const { @@ -6121,11 +6138,75 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_inode(::uint32_t value) _impl_.inet_diag_msg_inode_ = value; } +// string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_dest_network_owner_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); +} +inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_dest_network_owner() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) + return _internal_inet_diag_msg_socket_dest_network_owner(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_inet_diag_msg_socket_dest_network_owner(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + _impl_.inet_diag_msg_socket_dest_network_owner_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) +} +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_inet_diag_msg_socket_dest_network_owner() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + ::std::string* _s = _internal_mutable_inet_diag_msg_socket_dest_network_owner(); + // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) + return _s; +} +inline const ::std::string& XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_network_owner() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_socket_dest_network_owner_.Get(); +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_network_owner(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_dest_network_owner_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_inet_diag_msg_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.inet_diag_msg_socket_dest_network_owner_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + auto* released = _impl_.inet_diag_msg_socket_dest_network_owner_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.inet_diag_msg_socket_dest_network_owner_.Set("", GetArena()); + } + return released; +} +inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + } + _impl_.inet_diag_msg_socket_dest_network_owner_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inet_diag_msg_socket_dest_network_owner_.IsDefault()) { + _impl_.inet_diag_msg_socket_dest_network_owner_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) +} + // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; inline void XtcpFlatRecord::clear_mem_info_rmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_rmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x20000000U); + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) @@ -6133,7 +6214,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { } inline void XtcpFlatRecord::set_mem_info_rmem(::uint32_t value) { _internal_set_mem_info_rmem(value); - SetHasBit(_impl_._has_bits_[1], 0x20000000U); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_rmem() const { @@ -6149,7 +6230,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_rmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_wmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_wmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) @@ -6157,7 +6238,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { } inline void XtcpFlatRecord::set_mem_info_wmem(::uint32_t value) { _internal_set_mem_info_wmem(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_wmem() const { @@ -6173,7 +6254,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_wmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_fmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_fmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) @@ -6181,7 +6262,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { } inline void XtcpFlatRecord::set_mem_info_fmem(::uint32_t value) { _internal_set_mem_info_fmem(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_fmem() const { @@ -6197,7 +6278,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_fmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_tmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_tmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000001U); + ClearHasBit(_impl_._has_bits_[2], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) @@ -6205,7 +6286,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { } inline void XtcpFlatRecord::set_mem_info_tmem(::uint32_t value) { _internal_set_mem_info_tmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000001U); + SetHasBit(_impl_._has_bits_[2], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_tmem() const { @@ -6221,7 +6302,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_tmem(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000002U); + ClearHasBit(_impl_._has_bits_[2], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) @@ -6229,7 +6310,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { } inline void XtcpFlatRecord::set_tcp_info_state(::uint32_t value) { _internal_set_tcp_info_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000002U); + SetHasBit(_impl_._has_bits_[2], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_state() const { @@ -6245,7 +6326,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ca_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ca_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000004U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) @@ -6253,7 +6334,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { } inline void XtcpFlatRecord::set_tcp_info_ca_state(::uint32_t value) { _internal_set_tcp_info_ca_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000004U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ca_state() const { @@ -6269,7 +6350,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ca_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retransmits() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retransmits_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000008U); + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) @@ -6277,7 +6358,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { } inline void XtcpFlatRecord::set_tcp_info_retransmits(::uint32_t value) { _internal_set_tcp_info_retransmits(value); - SetHasBit(_impl_._has_bits_[2], 0x00000008U); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retransmits() const { @@ -6293,7 +6374,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retransmits(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_probes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_probes_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000010U); + ClearHasBit(_impl_._has_bits_[2], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) @@ -6301,7 +6382,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { } inline void XtcpFlatRecord::set_tcp_info_probes(::uint32_t value) { _internal_set_tcp_info_probes(value); - SetHasBit(_impl_._has_bits_[2], 0x00000010U); + SetHasBit(_impl_._has_bits_[2], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_probes() const { @@ -6317,7 +6398,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_probes(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_backoff() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_backoff_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000020U); + ClearHasBit(_impl_._has_bits_[2], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) @@ -6325,7 +6406,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { } inline void XtcpFlatRecord::set_tcp_info_backoff(::uint32_t value) { _internal_set_tcp_info_backoff(value); - SetHasBit(_impl_._has_bits_[2], 0x00000020U); + SetHasBit(_impl_._has_bits_[2], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_backoff() const { @@ -6341,7 +6422,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_backoff(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_options() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_options_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000040U); + ClearHasBit(_impl_._has_bits_[2], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) @@ -6349,7 +6430,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { } inline void XtcpFlatRecord::set_tcp_info_options(::uint32_t value) { _internal_set_tcp_info_options(value); - SetHasBit(_impl_._has_bits_[2], 0x00000040U); + SetHasBit(_impl_._has_bits_[2], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_options() const { @@ -6365,7 +6446,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_options(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_send_scale() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_send_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000080U); + ClearHasBit(_impl_._has_bits_[2], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::tcp_info_send_scale() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) @@ -6373,7 +6454,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_send_scale() const { } inline void XtcpFlatRecord::set_tcp_info_send_scale(::uint32_t value) { _internal_set_tcp_info_send_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000080U); + SetHasBit(_impl_._has_bits_[2], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_send_scale() const { @@ -6389,7 +6470,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_send_scale(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_scale() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000100U); + ClearHasBit(_impl_._has_bits_[2], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_scale() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) @@ -6397,7 +6478,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_scale() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_scale(::uint32_t value) { _internal_set_tcp_info_rcv_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000100U); + SetHasBit(_impl_._has_bits_[2], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_scale() const { @@ -6413,7 +6494,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_scale(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_delivery_rate_app_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivery_rate_app_limited_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000200U); + ClearHasBit(_impl_._has_bits_[2], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) @@ -6421,7 +6502,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { } inline void XtcpFlatRecord::set_tcp_info_delivery_rate_app_limited(::uint32_t value) { _internal_set_tcp_info_delivery_rate_app_limited(value); - SetHasBit(_impl_._has_bits_[2], 0x00000200U); + SetHasBit(_impl_._has_bits_[2], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivery_rate_app_limited() const { @@ -6437,7 +6518,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivery_rate_app_limited(::u inline void XtcpFlatRecord::clear_tcp_info_fast_open_client_failed() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_fast_open_client_failed_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000400U); + ClearHasBit(_impl_._has_bits_[2], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::tcp_info_fast_open_client_failed() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) @@ -6445,7 +6526,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_fast_open_client_failed() const { } inline void XtcpFlatRecord::set_tcp_info_fast_open_client_failed(::uint32_t value) { _internal_set_tcp_info_fast_open_client_failed(value); - SetHasBit(_impl_._has_bits_[2], 0x00000400U); + SetHasBit(_impl_._has_bits_[2], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fast_open_client_failed() const { @@ -6461,7 +6542,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_fast_open_client_failed(::uin inline void XtcpFlatRecord::clear_tcp_info_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000800U); + ClearHasBit(_impl_._has_bits_[2], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) @@ -6469,7 +6550,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { } inline void XtcpFlatRecord::set_tcp_info_rto(::uint32_t value) { _internal_set_tcp_info_rto(value); - SetHasBit(_impl_._has_bits_[2], 0x00000800U); + SetHasBit(_impl_._has_bits_[2], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rto() const { @@ -6485,7 +6566,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ato() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ato_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00001000U); + ClearHasBit(_impl_._has_bits_[2], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) @@ -6493,7 +6574,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { } inline void XtcpFlatRecord::set_tcp_info_ato(::uint32_t value) { _internal_set_tcp_info_ato(value); - SetHasBit(_impl_._has_bits_[2], 0x00001000U); + SetHasBit(_impl_._has_bits_[2], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ato() const { @@ -6509,7 +6590,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ato(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_snd_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00002000U); + ClearHasBit(_impl_._has_bits_[2], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) @@ -6517,7 +6598,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { } inline void XtcpFlatRecord::set_tcp_info_snd_mss(::uint32_t value) { _internal_set_tcp_info_snd_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00002000U); + SetHasBit(_impl_._has_bits_[2], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_mss() const { @@ -6533,7 +6614,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00004000U); + ClearHasBit(_impl_._has_bits_[2], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) @@ -6541,7 +6622,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_mss(::uint32_t value) { _internal_set_tcp_info_rcv_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00004000U); + SetHasBit(_impl_._has_bits_[2], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_mss() const { @@ -6557,7 +6638,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_unacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_unacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00008000U); + ClearHasBit(_impl_._has_bits_[2], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) @@ -6565,7 +6646,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { } inline void XtcpFlatRecord::set_tcp_info_unacked(::uint32_t value) { _internal_set_tcp_info_unacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00008000U); + SetHasBit(_impl_._has_bits_[2], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_unacked() const { @@ -6581,7 +6662,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_unacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_sacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00010000U); + ClearHasBit(_impl_._has_bits_[2], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) @@ -6589,7 +6670,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { } inline void XtcpFlatRecord::set_tcp_info_sacked(::uint32_t value) { _internal_set_tcp_info_sacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00010000U); + SetHasBit(_impl_._has_bits_[2], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_sacked() const { @@ -6605,7 +6686,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_lost() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_lost_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00020000U); + ClearHasBit(_impl_._has_bits_[2], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) @@ -6613,7 +6694,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { } inline void XtcpFlatRecord::set_tcp_info_lost(::uint32_t value) { _internal_set_tcp_info_lost(value); - SetHasBit(_impl_._has_bits_[2], 0x00020000U); + SetHasBit(_impl_._has_bits_[2], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_lost() const { @@ -6629,7 +6710,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_lost(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00040000U); + ClearHasBit(_impl_._has_bits_[2], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) @@ -6637,7 +6718,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_retrans(::uint32_t value) { _internal_set_tcp_info_retrans(value); - SetHasBit(_impl_._has_bits_[2], 0x00040000U); + SetHasBit(_impl_._has_bits_[2], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retrans() const { @@ -6653,7 +6734,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retrans(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_fackets() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_fackets_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00080000U); + ClearHasBit(_impl_._has_bits_[2], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) @@ -6661,7 +6742,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { } inline void XtcpFlatRecord::set_tcp_info_fackets(::uint32_t value) { _internal_set_tcp_info_fackets(value); - SetHasBit(_impl_._has_bits_[2], 0x00080000U); + SetHasBit(_impl_._has_bits_[2], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fackets() const { @@ -6677,7 +6758,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_fackets(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_last_data_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00100000U); + ClearHasBit(_impl_._has_bits_[2], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) @@ -6685,7 +6766,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_sent(::uint32_t value) { _internal_set_tcp_info_last_data_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00100000U); + SetHasBit(_impl_._has_bits_[2], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_sent() const { @@ -6701,7 +6782,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_sent(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00200000U); + ClearHasBit(_impl_._has_bits_[2], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) @@ -6709,7 +6790,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_sent(::uint32_t value) { _internal_set_tcp_info_last_ack_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00200000U); + SetHasBit(_impl_._has_bits_[2], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_sent() const { @@ -6725,7 +6806,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_sent(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_last_data_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00400000U); + ClearHasBit(_impl_._has_bits_[2], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) @@ -6733,7 +6814,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_recv(::uint32_t value) { _internal_set_tcp_info_last_data_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x00400000U); + SetHasBit(_impl_._has_bits_[2], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_recv() const { @@ -6749,7 +6830,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_recv(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00800000U); + ClearHasBit(_impl_._has_bits_[2], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) @@ -6757,7 +6838,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_recv(::uint32_t value) { _internal_set_tcp_info_last_ack_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x00800000U); + SetHasBit(_impl_._has_bits_[2], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_recv() const { @@ -6773,7 +6854,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_recv(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_pmtu() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_pmtu_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x01000000U); + ClearHasBit(_impl_._has_bits_[2], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) @@ -6781,7 +6862,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { } inline void XtcpFlatRecord::set_tcp_info_pmtu(::uint32_t value) { _internal_set_tcp_info_pmtu(value); - SetHasBit(_impl_._has_bits_[2], 0x01000000U); + SetHasBit(_impl_._has_bits_[2], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_pmtu() const { @@ -6797,7 +6878,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_pmtu(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x02000000U); + ClearHasBit(_impl_._has_bits_[2], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) @@ -6805,7 +6886,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ssthresh(::uint32_t value) { _internal_set_tcp_info_rcv_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x02000000U); + SetHasBit(_impl_._has_bits_[2], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ssthresh() const { @@ -6821,7 +6902,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x04000000U); + ClearHasBit(_impl_._has_bits_[2], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) @@ -6829,7 +6910,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rtt(::uint32_t value) { _internal_set_tcp_info_rtt(value); - SetHasBit(_impl_._has_bits_[2], 0x04000000U); + SetHasBit(_impl_._has_bits_[2], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt() const { @@ -6845,7 +6926,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rtt_var() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rtt_var_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x08000000U); + ClearHasBit(_impl_._has_bits_[2], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rtt_var() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) @@ -6853,7 +6934,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rtt_var() const { } inline void XtcpFlatRecord::set_tcp_info_rtt_var(::uint32_t value) { _internal_set_tcp_info_rtt_var(value); - SetHasBit(_impl_._has_bits_[2], 0x08000000U); + SetHasBit(_impl_._has_bits_[2], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt_var() const { @@ -6869,7 +6950,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rtt_var(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_snd_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x10000000U); + ClearHasBit(_impl_._has_bits_[2], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) @@ -6877,7 +6958,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_snd_ssthresh(::uint32_t value) { _internal_set_tcp_info_snd_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x10000000U); + SetHasBit(_impl_._has_bits_[2], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_ssthresh() const { @@ -6893,7 +6974,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_snd_cwnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_cwnd_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x20000000U); + ClearHasBit(_impl_._has_bits_[2], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) @@ -6901,7 +6982,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_cwnd(::uint32_t value) { _internal_set_tcp_info_snd_cwnd(value); - SetHasBit(_impl_._has_bits_[2], 0x20000000U); + SetHasBit(_impl_._has_bits_[2], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_cwnd() const { @@ -6917,7 +6998,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_cwnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_adv_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_adv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x40000000U); + ClearHasBit(_impl_._has_bits_[2], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_adv_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) @@ -6925,7 +7006,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_adv_mss() const { } inline void XtcpFlatRecord::set_tcp_info_adv_mss(::uint32_t value) { _internal_set_tcp_info_adv_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x40000000U); + SetHasBit(_impl_._has_bits_[2], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_adv_mss() const { @@ -6941,7 +7022,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_adv_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_reordering() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reordering_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x80000000U); + ClearHasBit(_impl_._has_bits_[3], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) @@ -6949,7 +7030,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { } inline void XtcpFlatRecord::set_tcp_info_reordering(::uint32_t value) { _internal_set_tcp_info_reordering(value); - SetHasBit(_impl_._has_bits_[2], 0x80000000U); + SetHasBit(_impl_._has_bits_[3], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reordering() const { @@ -6965,7 +7046,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reordering(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000001U); + ClearHasBit(_impl_._has_bits_[3], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) @@ -6973,7 +7054,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_rtt(::uint32_t value) { _internal_set_tcp_info_rcv_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00000001U); + SetHasBit(_impl_._has_bits_[3], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_rtt() const { @@ -6989,7 +7070,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_space() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_space_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000002U); + ClearHasBit(_impl_._has_bits_[3], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) @@ -6997,7 +7078,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_space(::uint32_t value) { _internal_set_tcp_info_rcv_space(value); - SetHasBit(_impl_._has_bits_[3], 0x00000002U); + SetHasBit(_impl_._has_bits_[3], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_space() const { @@ -7013,7 +7094,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_space(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000004U); + ClearHasBit(_impl_._has_bits_[3], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) @@ -7021,7 +7102,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_total_retrans(::uint32_t value) { _internal_set_tcp_info_total_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00000004U); + SetHasBit(_impl_._has_bits_[3], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_retrans() const { @@ -7037,7 +7118,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_retrans(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_pacing_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_pacing_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000008U); + ClearHasBit(_impl_._has_bits_[3], 0x00000010U); } inline ::uint64_t XtcpFlatRecord::tcp_info_pacing_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pacing_rate) @@ -7045,7 +7126,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_pacing_rate() const { } inline void XtcpFlatRecord::set_tcp_info_pacing_rate(::uint64_t value) { _internal_set_tcp_info_pacing_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00000008U); + SetHasBit(_impl_._has_bits_[3], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pacing_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_pacing_rate() const { @@ -7061,7 +7142,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_pacing_rate(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_max_pacing_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_max_pacing_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000010U); + ClearHasBit(_impl_._has_bits_[3], 0x00000020U); } inline ::uint64_t XtcpFlatRecord::tcp_info_max_pacing_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_max_pacing_rate) @@ -7069,7 +7150,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_max_pacing_rate() const { } inline void XtcpFlatRecord::set_tcp_info_max_pacing_rate(::uint64_t value) { _internal_set_tcp_info_max_pacing_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00000010U); + SetHasBit(_impl_._has_bits_[3], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_max_pacing_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_max_pacing_rate() const { @@ -7085,7 +7166,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_max_pacing_rate(::uint64_t va inline void XtcpFlatRecord::clear_tcp_info_bytes_acked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_acked_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000020U); + ClearHasBit(_impl_._has_bits_[3], 0x00000040U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) @@ -7093,7 +7174,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_acked(::uint64_t value) { _internal_set_tcp_info_bytes_acked(value); - SetHasBit(_impl_._has_bits_[3], 0x00000020U); + SetHasBit(_impl_._has_bits_[3], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_acked() const { @@ -7109,7 +7190,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_acked(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_received() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_received_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000040U); + ClearHasBit(_impl_._has_bits_[3], 0x00000080U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) @@ -7117,7 +7198,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_received(::uint64_t value) { _internal_set_tcp_info_bytes_received(value); - SetHasBit(_impl_._has_bits_[3], 0x00000040U); + SetHasBit(_impl_._has_bits_[3], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_received() const { @@ -7133,7 +7214,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_received(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000080U); + ClearHasBit(_impl_._has_bits_[3], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) @@ -7141,7 +7222,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_segs_out(::uint32_t value) { _internal_set_tcp_info_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00000080U); + SetHasBit(_impl_._has_bits_[3], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_out() const { @@ -7157,7 +7238,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_out(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000100U); + ClearHasBit(_impl_._has_bits_[3], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) @@ -7165,7 +7246,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_segs_in(::uint32_t value) { _internal_set_tcp_info_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00000100U); + SetHasBit(_impl_._has_bits_[3], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_in() const { @@ -7181,7 +7262,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_in(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_not_sent_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_not_sent_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000200U); + ClearHasBit(_impl_._has_bits_[3], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_not_sent_bytes() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) @@ -7189,7 +7270,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_not_sent_bytes() const { } inline void XtcpFlatRecord::set_tcp_info_not_sent_bytes(::uint32_t value) { _internal_set_tcp_info_not_sent_bytes(value); - SetHasBit(_impl_._has_bits_[3], 0x00000200U); + SetHasBit(_impl_._has_bits_[3], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_not_sent_bytes() const { @@ -7205,7 +7286,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_not_sent_bytes(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000400U); + ClearHasBit(_impl_._has_bits_[3], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) @@ -7213,7 +7294,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_min_rtt(::uint32_t value) { _internal_set_tcp_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00000400U); + SetHasBit(_impl_._has_bits_[3], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_min_rtt() const { @@ -7229,7 +7310,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_data_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000800U); + ClearHasBit(_impl_._has_bits_[3], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) @@ -7237,7 +7318,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_in(::uint32_t value) { _internal_set_tcp_info_data_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00000800U); + SetHasBit(_impl_._has_bits_[3], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_in() const { @@ -7253,7 +7334,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_data_segs_in(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_data_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00001000U); + ClearHasBit(_impl_._has_bits_[3], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) @@ -7261,7 +7342,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_out(::uint32_t value) { _internal_set_tcp_info_data_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00001000U); + SetHasBit(_impl_._has_bits_[3], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_out() const { @@ -7277,7 +7358,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_data_segs_out(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_delivery_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivery_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00002000U); + ClearHasBit(_impl_._has_bits_[3], 0x00004000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_delivery_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate) @@ -7285,7 +7366,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_delivery_rate() const { } inline void XtcpFlatRecord::set_tcp_info_delivery_rate(::uint64_t value) { _internal_set_tcp_info_delivery_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00002000U); + SetHasBit(_impl_._has_bits_[3], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_delivery_rate() const { @@ -7301,7 +7382,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivery_rate(::uint64_t valu inline void XtcpFlatRecord::clear_tcp_info_busy_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_busy_time_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00004000U); + ClearHasBit(_impl_._has_bits_[3], 0x00008000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_busy_time() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_busy_time) @@ -7309,7 +7390,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_busy_time() const { } inline void XtcpFlatRecord::set_tcp_info_busy_time(::uint64_t value) { _internal_set_tcp_info_busy_time(value); - SetHasBit(_impl_._has_bits_[3], 0x00004000U); + SetHasBit(_impl_._has_bits_[3], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_busy_time) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_busy_time() const { @@ -7325,7 +7406,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_busy_time(::uint64_t value) { inline void XtcpFlatRecord::clear_tcp_info_rwnd_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rwnd_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00008000U); + ClearHasBit(_impl_._has_bits_[3], 0x00010000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) @@ -7333,7 +7414,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { } inline void XtcpFlatRecord::set_tcp_info_rwnd_limited(::uint64_t value) { _internal_set_tcp_info_rwnd_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00008000U); + SetHasBit(_impl_._has_bits_[3], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_rwnd_limited() const { @@ -7349,7 +7430,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rwnd_limited(::uint64_t value inline void XtcpFlatRecord::clear_tcp_info_sndbuf_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sndbuf_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00010000U); + ClearHasBit(_impl_._has_bits_[3], 0x00020000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) @@ -7357,7 +7438,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { } inline void XtcpFlatRecord::set_tcp_info_sndbuf_limited(::uint64_t value) { _internal_set_tcp_info_sndbuf_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00010000U); + SetHasBit(_impl_._has_bits_[3], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_sndbuf_limited() const { @@ -7373,7 +7454,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sndbuf_limited(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_delivered() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00020000U); + ClearHasBit(_impl_._has_bits_[3], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) @@ -7381,7 +7462,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { } inline void XtcpFlatRecord::set_tcp_info_delivered(::uint32_t value) { _internal_set_tcp_info_delivered(value); - SetHasBit(_impl_._has_bits_[3], 0x00020000U); + SetHasBit(_impl_._has_bits_[3], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered() const { @@ -7397,7 +7478,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivered(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_delivered_ce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ce_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00040000U); + ClearHasBit(_impl_._has_bits_[3], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) @@ -7405,7 +7486,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { } inline void XtcpFlatRecord::set_tcp_info_delivered_ce(::uint32_t value) { _internal_set_tcp_info_delivered_ce(value); - SetHasBit(_impl_._has_bits_[3], 0x00040000U); + SetHasBit(_impl_._has_bits_[3], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered_ce() const { @@ -7421,7 +7502,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivered_ce(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_bytes_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_sent_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00080000U); + ClearHasBit(_impl_._has_bits_[3], 0x00100000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_sent) @@ -7429,7 +7510,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_sent() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_sent(::uint64_t value) { _internal_set_tcp_info_bytes_sent(value); - SetHasBit(_impl_._has_bits_[3], 0x00080000U); + SetHasBit(_impl_._has_bits_[3], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_sent) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_sent() const { @@ -7445,7 +7526,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_sent(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_retrans_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00100000U); + ClearHasBit(_impl_._has_bits_[3], 0x00200000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) @@ -7453,7 +7534,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_retrans(::uint64_t value) { _internal_set_tcp_info_bytes_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00100000U); + SetHasBit(_impl_._has_bits_[3], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_retrans() const { @@ -7469,7 +7550,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_retrans(::uint64_t valu inline void XtcpFlatRecord::clear_tcp_info_dsack_dups() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_dsack_dups_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00200000U); + ClearHasBit(_impl_._has_bits_[3], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_dsack_dups() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_dsack_dups) @@ -7477,7 +7558,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_dsack_dups() const { } inline void XtcpFlatRecord::set_tcp_info_dsack_dups(::uint32_t value) { _internal_set_tcp_info_dsack_dups(value); - SetHasBit(_impl_._has_bits_[3], 0x00200000U); + SetHasBit(_impl_._has_bits_[3], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_dsack_dups) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_dsack_dups() const { @@ -7493,7 +7574,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_dsack_dups(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_reord_seen() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reord_seen_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00400000U); + ClearHasBit(_impl_._has_bits_[3], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) @@ -7501,7 +7582,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { } inline void XtcpFlatRecord::set_tcp_info_reord_seen(::uint32_t value) { _internal_set_tcp_info_reord_seen(value); - SetHasBit(_impl_._has_bits_[3], 0x00400000U); + SetHasBit(_impl_._has_bits_[3], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reord_seen() const { @@ -7517,7 +7598,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reord_seen(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_ooopack() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ooopack_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00800000U); + ClearHasBit(_impl_._has_bits_[3], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) @@ -7525,7 +7606,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ooopack(::uint32_t value) { _internal_set_tcp_info_rcv_ooopack(value); - SetHasBit(_impl_._has_bits_[3], 0x00800000U); + SetHasBit(_impl_._has_bits_[3], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ooopack() const { @@ -7541,7 +7622,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ooopack(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_snd_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x01000000U); + ClearHasBit(_impl_._has_bits_[3], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) @@ -7549,7 +7630,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_wnd(::uint32_t value) { _internal_set_tcp_info_snd_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x01000000U); + SetHasBit(_impl_._has_bits_[3], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_wnd() const { @@ -7565,7 +7646,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x02000000U); + ClearHasBit(_impl_._has_bits_[3], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) @@ -7573,7 +7654,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_wnd(::uint32_t value) { _internal_set_tcp_info_rcv_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x02000000U); + SetHasBit(_impl_._has_bits_[3], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_wnd() const { @@ -7589,7 +7670,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rehash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rehash_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x04000000U); + ClearHasBit(_impl_._has_bits_[3], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) @@ -7597,7 +7678,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { } inline void XtcpFlatRecord::set_tcp_info_rehash(::uint32_t value) { _internal_set_tcp_info_rehash(value); - SetHasBit(_impl_._has_bits_[3], 0x04000000U); + SetHasBit(_impl_._has_bits_[3], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rehash() const { @@ -7613,7 +7694,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rehash(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x08000000U); + ClearHasBit(_impl_._has_bits_[3], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) @@ -7621,7 +7702,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto(::uint32_t value) { _internal_set_tcp_info_total_rto(value); - SetHasBit(_impl_._has_bits_[3], 0x08000000U); + SetHasBit(_impl_._has_bits_[3], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto() const { @@ -7637,7 +7718,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto_recoveries() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_recoveries_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x10000000U); + ClearHasBit(_impl_._has_bits_[3], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) @@ -7645,7 +7726,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_recoveries(::uint32_t value) { _internal_set_tcp_info_total_rto_recoveries(value); - SetHasBit(_impl_._has_bits_[3], 0x10000000U); + SetHasBit(_impl_._has_bits_[3], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_recoveries() const { @@ -7661,7 +7742,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto_recoveries(::uint32 inline void XtcpFlatRecord::clear_tcp_info_total_rto_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_time_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x20000000U); + ClearHasBit(_impl_._has_bits_[3], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) @@ -7669,7 +7750,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_time(::uint32_t value) { _internal_set_tcp_info_total_rto_time(value); - SetHasBit(_impl_._has_bits_[3], 0x20000000U); + SetHasBit(_impl_._has_bits_[3], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_time() const { @@ -7685,7 +7766,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto_time(::uint32_t val inline void XtcpFlatRecord::clear_congestion_algorithm_string() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.congestion_algorithm_string_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } inline const ::std::string& XtcpFlatRecord::congestion_algorithm_string() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -7695,13 +7776,13 @@ inline const ::std::string& XtcpFlatRecord::congestion_algorithm_string() const template PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_congestion_algorithm_string(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); _impl_.congestion_algorithm_string_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) } inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_congestion_algorithm_string() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); ::std::string* _s = _internal_mutable_congestion_algorithm_string(); // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) return _s; @@ -7721,10 +7802,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_congest inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_congestion_algorithm_string() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000200U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); auto* released = _impl_.congestion_algorithm_string_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.congestion_algorithm_string_.Set("", GetArena()); @@ -7734,9 +7815,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_congestion_algor inline void XtcpFlatRecord::set_allocated_congestion_algorithm_string(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } _impl_.congestion_algorithm_string_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.congestion_algorithm_string_.IsDefault()) { @@ -7749,7 +7830,7 @@ inline void XtcpFlatRecord::set_allocated_congestion_algorithm_string(::std::str inline void XtcpFlatRecord::clear_congestion_algorithm_enum() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.congestion_algorithm_enum_ = 0; - ClearHasBit(_impl_._has_bits_[3], 0x40000000U); + ClearHasBit(_impl_._has_bits_[3], 0x80000000U); } inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::congestion_algorithm_enum() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) @@ -7757,7 +7838,7 @@ inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord } inline void XtcpFlatRecord::set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { _internal_set_congestion_algorithm_enum(value); - SetHasBit(_impl_._has_bits_[3], 0x40000000U); + SetHasBit(_impl_._has_bits_[3], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) } inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::_internal_congestion_algorithm_enum() const { @@ -7773,7 +7854,7 @@ inline void XtcpFlatRecord::_internal_set_congestion_algorithm_enum(::xtcp_flat_ inline void XtcpFlatRecord::clear_type_of_service() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_of_service_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x80000000U); + ClearHasBit(_impl_._has_bits_[4], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::type_of_service() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) @@ -7781,7 +7862,7 @@ inline ::uint32_t XtcpFlatRecord::type_of_service() const { } inline void XtcpFlatRecord::set_type_of_service(::uint32_t value) { _internal_set_type_of_service(value); - SetHasBit(_impl_._has_bits_[3], 0x80000000U); + SetHasBit(_impl_._has_bits_[4], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) } inline ::uint32_t XtcpFlatRecord::_internal_type_of_service() const { @@ -7797,7 +7878,7 @@ inline void XtcpFlatRecord::_internal_set_type_of_service(::uint32_t value) { inline void XtcpFlatRecord::clear_traffic_class() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.traffic_class_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000001U); + ClearHasBit(_impl_._has_bits_[4], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::traffic_class() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) @@ -7805,7 +7886,7 @@ inline ::uint32_t XtcpFlatRecord::traffic_class() const { } inline void XtcpFlatRecord::set_traffic_class(::uint32_t value) { _internal_set_traffic_class(value); - SetHasBit(_impl_._has_bits_[4], 0x00000001U); + SetHasBit(_impl_._has_bits_[4], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) } inline ::uint32_t XtcpFlatRecord::_internal_traffic_class() const { @@ -7821,7 +7902,7 @@ inline void XtcpFlatRecord::_internal_set_traffic_class(::uint32_t value) { inline void XtcpFlatRecord::clear_sk_mem_info_rmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_rmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000002U); + ClearHasBit(_impl_._has_bits_[4], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) @@ -7829,7 +7910,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_rmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_rmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000002U); + SetHasBit(_impl_._has_bits_[4], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rmem_alloc() const { @@ -7845,7 +7926,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_rmem_alloc(::uint32_t valu inline void XtcpFlatRecord::clear_sk_mem_info_rcv_buf() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_rcv_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000004U); + ClearHasBit(_impl_._has_bits_[4], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcv_buf() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) @@ -7853,7 +7934,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcv_buf() const { } inline void XtcpFlatRecord::set_sk_mem_info_rcv_buf(::uint32_t value) { _internal_set_sk_mem_info_rcv_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000004U); + SetHasBit(_impl_._has_bits_[4], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rcv_buf() const { @@ -7869,7 +7950,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_rcv_buf(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_wmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000008U); + ClearHasBit(_impl_._has_bits_[4], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) @@ -7877,7 +7958,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_wmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000008U); + SetHasBit(_impl_._has_bits_[4], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_alloc() const { @@ -7893,7 +7974,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_alloc(::uint32_t valu inline void XtcpFlatRecord::clear_sk_mem_info_snd_buf() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_snd_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000010U); + ClearHasBit(_impl_._has_bits_[4], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_snd_buf() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) @@ -7901,7 +7982,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_snd_buf() const { } inline void XtcpFlatRecord::set_sk_mem_info_snd_buf(::uint32_t value) { _internal_set_sk_mem_info_snd_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000010U); + SetHasBit(_impl_._has_bits_[4], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_snd_buf() const { @@ -7917,7 +7998,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_snd_buf(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_fwd_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_fwd_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000020U); + ClearHasBit(_impl_._has_bits_[4], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) @@ -7925,7 +8006,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_fwd_alloc(::uint32_t value) { _internal_set_sk_mem_info_fwd_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000020U); + SetHasBit(_impl_._has_bits_[4], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_fwd_alloc() const { @@ -7941,7 +8022,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_fwd_alloc(::uint32_t value inline void XtcpFlatRecord::clear_sk_mem_info_wmem_queued() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_queued_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000040U); + ClearHasBit(_impl_._has_bits_[4], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) @@ -7949,7 +8030,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_queued(::uint32_t value) { _internal_set_sk_mem_info_wmem_queued(value); - SetHasBit(_impl_._has_bits_[4], 0x00000040U); + SetHasBit(_impl_._has_bits_[4], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_queued() const { @@ -7965,7 +8046,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_queued(::uint32_t val inline void XtcpFlatRecord::clear_sk_mem_info_optmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_optmem_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000080U); + ClearHasBit(_impl_._has_bits_[4], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) @@ -7973,7 +8054,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { } inline void XtcpFlatRecord::set_sk_mem_info_optmem(::uint32_t value) { _internal_set_sk_mem_info_optmem(value); - SetHasBit(_impl_._has_bits_[4], 0x00000080U); + SetHasBit(_impl_._has_bits_[4], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_optmem() const { @@ -7989,7 +8070,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_optmem(::uint32_t value) { inline void XtcpFlatRecord::clear_sk_mem_info_backlog() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_backlog_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000100U); + ClearHasBit(_impl_._has_bits_[4], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) @@ -7997,7 +8078,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { } inline void XtcpFlatRecord::set_sk_mem_info_backlog(::uint32_t value) { _internal_set_sk_mem_info_backlog(value); - SetHasBit(_impl_._has_bits_[4], 0x00000100U); + SetHasBit(_impl_._has_bits_[4], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_backlog() const { @@ -8013,7 +8094,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_backlog(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_drops() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_drops_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000200U); + ClearHasBit(_impl_._has_bits_[4], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) @@ -8021,7 +8102,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { } inline void XtcpFlatRecord::set_sk_mem_info_drops(::uint32_t value) { _internal_set_sk_mem_info_drops(value); - SetHasBit(_impl_._has_bits_[4], 0x00000200U); + SetHasBit(_impl_._has_bits_[4], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_drops() const { @@ -8037,7 +8118,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_drops(::uint32_t value) { inline void XtcpFlatRecord::clear_shutdown_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.shutdown_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000400U); + ClearHasBit(_impl_._has_bits_[4], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::shutdown_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) @@ -8045,7 +8126,7 @@ inline ::uint32_t XtcpFlatRecord::shutdown_state() const { } inline void XtcpFlatRecord::set_shutdown_state(::uint32_t value) { _internal_set_shutdown_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00000400U); + SetHasBit(_impl_._has_bits_[4], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) } inline ::uint32_t XtcpFlatRecord::_internal_shutdown_state() const { @@ -8061,7 +8142,7 @@ inline void XtcpFlatRecord::_internal_set_shutdown_state(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000800U); + ClearHasBit(_impl_._has_bits_[4], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) @@ -8069,7 +8150,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { } inline void XtcpFlatRecord::set_vegas_info_enabled(::uint32_t value) { _internal_set_vegas_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00000800U); + SetHasBit(_impl_._has_bits_[4], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_enabled() const { @@ -8085,7 +8166,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_enabled(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_rtt_cnt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_rtt_cnt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00001000U); + ClearHasBit(_impl_._has_bits_[4], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_rtt_cnt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) @@ -8093,7 +8174,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_rtt_cnt() const { } inline void XtcpFlatRecord::set_vegas_info_rtt_cnt(::uint32_t value) { _internal_set_vegas_info_rtt_cnt(value); - SetHasBit(_impl_._has_bits_[4], 0x00001000U); + SetHasBit(_impl_._has_bits_[4], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt_cnt() const { @@ -8109,7 +8190,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_rtt_cnt(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00002000U); + ClearHasBit(_impl_._has_bits_[4], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) @@ -8117,7 +8198,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { } inline void XtcpFlatRecord::set_vegas_info_rtt(::uint32_t value) { _internal_set_vegas_info_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00002000U); + SetHasBit(_impl_._has_bits_[4], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt() const { @@ -8133,7 +8214,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00004000U); + ClearHasBit(_impl_._has_bits_[4], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) @@ -8141,7 +8222,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_min_rtt() const { } inline void XtcpFlatRecord::set_vegas_info_min_rtt(::uint32_t value) { _internal_set_vegas_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00004000U); + SetHasBit(_impl_._has_bits_[4], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_min_rtt() const { @@ -8157,7 +8238,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00008000U); + ClearHasBit(_impl_._has_bits_[4], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) @@ -8165,7 +8246,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { } inline void XtcpFlatRecord::set_dctcp_info_enabled(::uint32_t value) { _internal_set_dctcp_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00008000U); + SetHasBit(_impl_._has_bits_[4], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_enabled() const { @@ -8181,7 +8262,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_enabled(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ce_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ce_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00010000U); + ClearHasBit(_impl_._has_bits_[4], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) @@ -8189,7 +8270,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { } inline void XtcpFlatRecord::set_dctcp_info_ce_state(::uint32_t value) { _internal_set_dctcp_info_ce_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00010000U); + SetHasBit(_impl_._has_bits_[4], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ce_state() const { @@ -8205,7 +8286,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ce_state(::uint32_t value) inline void XtcpFlatRecord::clear_dctcp_info_alpha() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_alpha_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00020000U); + ClearHasBit(_impl_._has_bits_[4], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) @@ -8213,7 +8294,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { } inline void XtcpFlatRecord::set_dctcp_info_alpha(::uint32_t value) { _internal_set_dctcp_info_alpha(value); - SetHasBit(_impl_._has_bits_[4], 0x00020000U); + SetHasBit(_impl_._has_bits_[4], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_alpha() const { @@ -8229,7 +8310,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_alpha(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_ecn() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_ecn_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00040000U); + ClearHasBit(_impl_._has_bits_[4], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) @@ -8237,7 +8318,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_ecn(::uint32_t value) { _internal_set_dctcp_info_ab_ecn(value); - SetHasBit(_impl_._has_bits_[4], 0x00040000U); + SetHasBit(_impl_._has_bits_[4], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_ecn() const { @@ -8253,7 +8334,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_ecn(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_tot() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_tot_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00080000U); + ClearHasBit(_impl_._has_bits_[4], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) @@ -8261,7 +8342,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_tot(::uint32_t value) { _internal_set_dctcp_info_ab_tot(value); - SetHasBit(_impl_._has_bits_[4], 0x00080000U); + SetHasBit(_impl_._has_bits_[4], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_tot() const { @@ -8277,7 +8358,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_tot(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_lo_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00100000U); + ClearHasBit(_impl_._has_bits_[4], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) @@ -8285,7 +8366,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { } inline void XtcpFlatRecord::set_bbr_info_bw_lo(::uint32_t value) { _internal_set_bbr_info_bw_lo(value); - SetHasBit(_impl_._has_bits_[4], 0x00100000U); + SetHasBit(_impl_._has_bits_[4], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_lo() const { @@ -8301,7 +8382,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_lo(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_hi_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00200000U); + ClearHasBit(_impl_._has_bits_[4], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) @@ -8309,7 +8390,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { } inline void XtcpFlatRecord::set_bbr_info_bw_hi(::uint32_t value) { _internal_set_bbr_info_bw_hi(value); - SetHasBit(_impl_._has_bits_[4], 0x00200000U); + SetHasBit(_impl_._has_bits_[4], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_hi() const { @@ -8325,7 +8406,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_hi(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00400000U); + ClearHasBit(_impl_._has_bits_[4], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) @@ -8333,7 +8414,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { } inline void XtcpFlatRecord::set_bbr_info_min_rtt(::uint32_t value) { _internal_set_bbr_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00400000U); + SetHasBit(_impl_._has_bits_[4], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_min_rtt() const { @@ -8349,7 +8430,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_pacing_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_pacing_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00800000U); + ClearHasBit(_impl_._has_bits_[4], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) @@ -8357,7 +8438,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { } inline void XtcpFlatRecord::set_bbr_info_pacing_gain(::uint32_t value) { _internal_set_bbr_info_pacing_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x00800000U); + SetHasBit(_impl_._has_bits_[4], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_pacing_gain() const { @@ -8373,7 +8454,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_pacing_gain(::uint32_t value) inline void XtcpFlatRecord::clear_bbr_info_cwnd_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_cwnd_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x01000000U); + ClearHasBit(_impl_._has_bits_[4], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) @@ -8381,7 +8462,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { } inline void XtcpFlatRecord::set_bbr_info_cwnd_gain(::uint32_t value) { _internal_set_bbr_info_cwnd_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x01000000U); + SetHasBit(_impl_._has_bits_[4], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_cwnd_gain() const { @@ -8397,7 +8478,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_cwnd_gain(::uint32_t value) { inline void XtcpFlatRecord::clear_class_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.class_id_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x02000000U); + ClearHasBit(_impl_._has_bits_[4], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::class_id() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.class_id) @@ -8405,7 +8486,7 @@ inline ::uint32_t XtcpFlatRecord::class_id() const { } inline void XtcpFlatRecord::set_class_id(::uint32_t value) { _internal_set_class_id(value); - SetHasBit(_impl_._has_bits_[4], 0x02000000U); + SetHasBit(_impl_._has_bits_[4], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.class_id) } inline ::uint32_t XtcpFlatRecord::_internal_class_id() const { @@ -8421,7 +8502,7 @@ inline void XtcpFlatRecord::_internal_set_class_id(::uint32_t value) { inline void XtcpFlatRecord::clear_sock_opt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sock_opt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x04000000U); + ClearHasBit(_impl_._has_bits_[4], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::sock_opt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) @@ -8429,7 +8510,7 @@ inline ::uint32_t XtcpFlatRecord::sock_opt() const { } inline void XtcpFlatRecord::set_sock_opt(::uint32_t value) { _internal_set_sock_opt(value); - SetHasBit(_impl_._has_bits_[4], 0x04000000U); + SetHasBit(_impl_._has_bits_[4], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) } inline ::uint32_t XtcpFlatRecord::_internal_sock_opt() const { @@ -8445,7 +8526,7 @@ inline void XtcpFlatRecord::_internal_set_sock_opt(::uint32_t value) { inline void XtcpFlatRecord::clear_c_group() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.c_group_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[4], 0x08000000U); + ClearHasBit(_impl_._has_bits_[4], 0x10000000U); } inline ::uint64_t XtcpFlatRecord::c_group() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.c_group) @@ -8453,7 +8534,7 @@ inline ::uint64_t XtcpFlatRecord::c_group() const { } inline void XtcpFlatRecord::set_c_group(::uint64_t value) { _internal_set_c_group(value); - SetHasBit(_impl_._has_bits_[4], 0x08000000U); + SetHasBit(_impl_._has_bits_[4], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.c_group) } inline ::uint64_t XtcpFlatRecord::_internal_c_group() const { diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart index d5ddfee..9556f81 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart @@ -924,6 +924,9 @@ class XtcpConfig extends $pb.GeneratedMessage { $core.int? uplinkCount, $core.Iterable<$core.String>? uplinkInterfaces, $core.bool? populateNsid, + $core.bool? enrichAsnEnable, + $core.String? asnDbPath, + $1.Duration? asnRefreshInterval, }) { final result = create(); if (nlTimeoutMilliseconds != null) @@ -1010,6 +1013,10 @@ class XtcpConfig extends $pb.GeneratedMessage { if (uplinkInterfaces != null) result.uplinkInterfaces.addAll(uplinkInterfaces); if (populateNsid != null) result.populateNsid = populateNsid; + if (enrichAsnEnable != null) result.enrichAsnEnable = enrichAsnEnable; + if (asnDbPath != null) result.asnDbPath = asnDbPath; + if (asnRefreshInterval != null) + result.asnRefreshInterval = asnRefreshInterval; return result; } @@ -1127,6 +1134,10 @@ class XtcpConfig extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..pPS(237, _omitFieldNames ? '' : 'uplinkInterfaces') ..aOB(238, _omitFieldNames ? '' : 'populateNsid') + ..aOB(239, _omitFieldNames ? '' : 'enrichAsnEnable') + ..aOS(240, _omitFieldNames ? '' : 'asnDbPath') + ..aOM<$1.Duration>(241, _omitFieldNames ? '' : 'asnRefreshInterval', + subBuilder: $1.Duration.create) ..hasRequiredFields = false; @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.') @@ -1967,6 +1978,44 @@ class XtcpConfig extends $pb.GeneratedMessage { $core.bool hasPopulateNsid() => $_has(65); @$pb.TagNumber(238) void clearPopulateNsid() => $_clearField(238); + + /// Enrich the destination IP's ASN (field 1011) and network owner (field + /// 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + /// artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when + /// enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, + /// and leaves both columns empty. Default false. + @$pb.TagNumber(239) + $core.bool get enrichAsnEnable => $_getBF(66); + @$pb.TagNumber(239) + set enrichAsnEnable($core.bool value) => $_setBool(66, value); + @$pb.TagNumber(239) + $core.bool hasEnrichAsnEnable() => $_has(66); + @$pb.TagNumber(239) + void clearEnrichAsnEnable() => $_clearField(239); + + /// Path to the ipfeed-collector Parquet artifact (prefix -> {asn, + /// network_owner}). Default "". + @$pb.TagNumber(240) + $core.String get asnDbPath => $_getSZ(67); + @$pb.TagNumber(240) + set asnDbPath($core.String value) => $_setString(67, value); + @$pb.TagNumber(240) + $core.bool hasAsnDbPath() => $_has(67); + @$pb.TagNumber(240) + void clearAsnDbPath() => $_clearField(240); + + /// How often to reload asn_db_path in the background so a refreshed artifact + /// is picked up without a restart. 0 = load once at startup, never reload. + @$pb.TagNumber(241) + $1.Duration get asnRefreshInterval => $_getN(68); + @$pb.TagNumber(241) + set asnRefreshInterval($1.Duration value) => $_setField(241, value); + @$pb.TagNumber(241) + $core.bool hasAsnRefreshInterval() => $_has(68); + @$pb.TagNumber(241) + void clearAsnRefreshInterval() => $_clearField(241); + @$pb.TagNumber(241) + $1.Duration ensureAsnRefreshInterval() => $_ensure(68); } class EnabledDeserializers extends $pb.GeneratedMessage { diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart index c541a1d..90f3319 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart @@ -694,6 +694,22 @@ const XtcpConfig$json = { '10': 'uplinkInterfaces' }, {'1': 'populate_nsid', '3': 238, '4': 1, '5': 8, '10': 'populateNsid'}, + { + '1': 'enrich_asn_enable', + '3': 239, + '4': 1, + '5': 8, + '10': 'enrichAsnEnable' + }, + {'1': 'asn_db_path', '3': 240, '4': 1, '5': 9, '8': {}, '10': 'asnDbPath'}, + { + '1': 'asn_refresh_interval', + '3': 241, + '4': 1, + '5': 11, + '6': '.google.protobuf.Duration', + '10': 'asnRefreshInterval' + }, ], '7': {}, }; @@ -766,10 +782,13 @@ final $typed_data.Uint8List xtcpConfigDescriptor = $convert.base64Decode( '50GOoBIAEoCUIHukgEcgIYEFIQbGxkcGRWZXJzaW9uSGludBIrChFlbnJpY2hfbmljX2VuYWJs' 'ZRjrASABKAhSD2VucmljaE5pY0VuYWJsZRIrCgx1cGxpbmtfY291bnQY7AEgASgNQge6SAQqAh' 'gCUgt1cGxpbmtDb3VudBI2ChF1cGxpbmtfaW50ZXJmYWNlcxjtASADKAlCCLpIBZIBAhACUhB1' - 'cGxpbmtJbnRlcmZhY2VzEiQKDXBvcHVsYXRlX25zaWQY7gEgASgIUgxwb3B1bGF0ZU5zaWQ6c7' - 'pIcBpuCg9YdGNwQ29uZmlnLnBvbGwSMlBvbGwgdGltZW91dCBtdXN0IGJlIGxlc3MgdGhhbiBw' - 'b2xsIHBvbGxfZnJlcXVlbmN5Gid0aGlzLnBvbGxfZnJlcXVlbmN5ID4gdGhpcy5wb2xsX3RpbW' - 'VvdXQ='); + 'cGxpbmtJbnRlcmZhY2VzEiQKDXBvcHVsYXRlX25zaWQY7gEgASgIUgxwb3B1bGF0ZU5zaWQSKw' + 'oRZW5yaWNoX2Fzbl9lbmFibGUY7wEgASgIUg9lbnJpY2hBc25FbmFibGUSKQoLYXNuX2RiX3Bh' + 'dGgY8AEgASgJQgi6SAVyAxj/AVIJYXNuRGJQYXRoEkwKFGFzbl9yZWZyZXNoX2ludGVydmFsGP' + 'EBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvblISYXNuUmVmcmVzaEludGVydmFsOnO6' + 'SHAabgoPWHRjcENvbmZpZy5wb2xsEjJQb2xsIHRpbWVvdXQgbXVzdCBiZSBsZXNzIHRoYW4gcG' + '9sbCBwb2xsX2ZyZXF1ZW5jeRondGhpcy5wb2xsX2ZyZXF1ZW5jeSA+IHRoaXMucG9sbF90aW1l' + 'b3V0'); @$core.Deprecated('Use enabledDeserializersDescriptor instead') const EnabledDeserializers$json = { diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart index 3cbee5d..1c6253f 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart @@ -139,6 +139,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? inetDiagMsgWqueue, $core.int? inetDiagMsgUid, $core.int? inetDiagMsgInode, + $core.String? inetDiagMsgSocketDestNetworkOwner, $core.int? memInfoRmem, $core.int? memInfoWmem, $core.int? memInfoFmem, @@ -322,6 +323,9 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (inetDiagMsgWqueue != null) result.inetDiagMsgWqueue = inetDiagMsgWqueue; if (inetDiagMsgUid != null) result.inetDiagMsgUid = inetDiagMsgUid; if (inetDiagMsgInode != null) result.inetDiagMsgInode = inetDiagMsgInode; + if (inetDiagMsgSocketDestNetworkOwner != null) + result.inetDiagMsgSocketDestNetworkOwner = + inetDiagMsgSocketDestNetworkOwner; if (memInfoRmem != null) result.memInfoRmem = memInfoRmem; if (memInfoWmem != null) result.memInfoWmem = memInfoWmem; if (memInfoFmem != null) result.memInfoFmem = memInfoFmem; @@ -560,6 +564,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1017, _omitFieldNames ? '' : 'inetDiagMsgInode', fieldType: $pb.PbFieldType.OU3) + ..aOS(1018, _omitFieldNames ? '' : 'inetDiagMsgSocketDestNetworkOwner') ..aI(1101, _omitFieldNames ? '' : 'memInfoRmem', fieldType: $pb.PbFieldType.OU3) ..aI(1102, _omitFieldNames ? '' : 'memInfoWmem', @@ -1373,6 +1378,20 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { @$pb.TagNumber(1017) void clearInetDiagMsgInode() => $_clearField(1017); + /// Destination network owner (e.g. "cloudflare", "aws"), from the IP-range + /// feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the + /// opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the + /// destination IP is not in the feed set. + @$pb.TagNumber(1018) + $core.String get inetDiagMsgSocketDestNetworkOwner => $_getSZ(60); + @$pb.TagNumber(1018) + set inetDiagMsgSocketDestNetworkOwner($core.String value) => + $_setString(60, value); + @$pb.TagNumber(1018) + $core.bool hasInetDiagMsgSocketDestNetworkOwner() => $_has(60); + @$pb.TagNumber(1018) + void clearInetDiagMsgSocketDestNetworkOwner() => $_clearField(1018); + /// DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by /// default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), /// so these ship as 0 on current records. The same values live in sk_mem_info: @@ -1384,595 +1403,595 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// (Not marked `[deprecated = true]` so the still-supported opt-in decode path /// and tests don't trip staticcheck SA1019.) @$pb.TagNumber(1101) - $core.int get memInfoRmem => $_getIZ(60); + $core.int get memInfoRmem => $_getIZ(61); @$pb.TagNumber(1101) - set memInfoRmem($core.int value) => $_setUnsignedInt32(60, value); + set memInfoRmem($core.int value) => $_setUnsignedInt32(61, value); @$pb.TagNumber(1101) - $core.bool hasMemInfoRmem() => $_has(60); + $core.bool hasMemInfoRmem() => $_has(61); @$pb.TagNumber(1101) void clearMemInfoRmem() => $_clearField(1101); @$pb.TagNumber(1102) - $core.int get memInfoWmem => $_getIZ(61); + $core.int get memInfoWmem => $_getIZ(62); @$pb.TagNumber(1102) - set memInfoWmem($core.int value) => $_setUnsignedInt32(61, value); + set memInfoWmem($core.int value) => $_setUnsignedInt32(62, value); @$pb.TagNumber(1102) - $core.bool hasMemInfoWmem() => $_has(61); + $core.bool hasMemInfoWmem() => $_has(62); @$pb.TagNumber(1102) void clearMemInfoWmem() => $_clearField(1102); @$pb.TagNumber(1103) - $core.int get memInfoFmem => $_getIZ(62); + $core.int get memInfoFmem => $_getIZ(63); @$pb.TagNumber(1103) - set memInfoFmem($core.int value) => $_setUnsignedInt32(62, value); + set memInfoFmem($core.int value) => $_setUnsignedInt32(63, value); @$pb.TagNumber(1103) - $core.bool hasMemInfoFmem() => $_has(62); + $core.bool hasMemInfoFmem() => $_has(63); @$pb.TagNumber(1103) void clearMemInfoFmem() => $_clearField(1103); @$pb.TagNumber(1104) - $core.int get memInfoTmem => $_getIZ(63); + $core.int get memInfoTmem => $_getIZ(64); @$pb.TagNumber(1104) - set memInfoTmem($core.int value) => $_setUnsignedInt32(63, value); + set memInfoTmem($core.int value) => $_setUnsignedInt32(64, value); @$pb.TagNumber(1104) - $core.bool hasMemInfoTmem() => $_has(63); + $core.bool hasMemInfoTmem() => $_has(64); @$pb.TagNumber(1104) void clearMemInfoTmem() => $_clearField(1104); @$pb.TagNumber(1201) - $core.int get tcpInfoState => $_getIZ(64); + $core.int get tcpInfoState => $_getIZ(65); @$pb.TagNumber(1201) - set tcpInfoState($core.int value) => $_setUnsignedInt32(64, value); + set tcpInfoState($core.int value) => $_setUnsignedInt32(65, value); @$pb.TagNumber(1201) - $core.bool hasTcpInfoState() => $_has(64); + $core.bool hasTcpInfoState() => $_has(65); @$pb.TagNumber(1201) void clearTcpInfoState() => $_clearField(1201); @$pb.TagNumber(1202) - $core.int get tcpInfoCaState => $_getIZ(65); + $core.int get tcpInfoCaState => $_getIZ(66); @$pb.TagNumber(1202) - set tcpInfoCaState($core.int value) => $_setUnsignedInt32(65, value); + set tcpInfoCaState($core.int value) => $_setUnsignedInt32(66, value); @$pb.TagNumber(1202) - $core.bool hasTcpInfoCaState() => $_has(65); + $core.bool hasTcpInfoCaState() => $_has(66); @$pb.TagNumber(1202) void clearTcpInfoCaState() => $_clearField(1202); @$pb.TagNumber(1203) - $core.int get tcpInfoRetransmits => $_getIZ(66); + $core.int get tcpInfoRetransmits => $_getIZ(67); @$pb.TagNumber(1203) - set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(66, value); + set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(67, value); @$pb.TagNumber(1203) - $core.bool hasTcpInfoRetransmits() => $_has(66); + $core.bool hasTcpInfoRetransmits() => $_has(67); @$pb.TagNumber(1203) void clearTcpInfoRetransmits() => $_clearField(1203); @$pb.TagNumber(1204) - $core.int get tcpInfoProbes => $_getIZ(67); + $core.int get tcpInfoProbes => $_getIZ(68); @$pb.TagNumber(1204) - set tcpInfoProbes($core.int value) => $_setUnsignedInt32(67, value); + set tcpInfoProbes($core.int value) => $_setUnsignedInt32(68, value); @$pb.TagNumber(1204) - $core.bool hasTcpInfoProbes() => $_has(67); + $core.bool hasTcpInfoProbes() => $_has(68); @$pb.TagNumber(1204) void clearTcpInfoProbes() => $_clearField(1204); @$pb.TagNumber(1205) - $core.int get tcpInfoBackoff => $_getIZ(68); + $core.int get tcpInfoBackoff => $_getIZ(69); @$pb.TagNumber(1205) - set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(68, value); + set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(69, value); @$pb.TagNumber(1205) - $core.bool hasTcpInfoBackoff() => $_has(68); + $core.bool hasTcpInfoBackoff() => $_has(69); @$pb.TagNumber(1205) void clearTcpInfoBackoff() => $_clearField(1205); @$pb.TagNumber(1206) - $core.int get tcpInfoOptions => $_getIZ(69); + $core.int get tcpInfoOptions => $_getIZ(70); @$pb.TagNumber(1206) - set tcpInfoOptions($core.int value) => $_setUnsignedInt32(69, value); + set tcpInfoOptions($core.int value) => $_setUnsignedInt32(70, value); @$pb.TagNumber(1206) - $core.bool hasTcpInfoOptions() => $_has(69); + $core.bool hasTcpInfoOptions() => $_has(70); @$pb.TagNumber(1206) void clearTcpInfoOptions() => $_clearField(1206); /// __u8 _snd_wscale : 4, _rcv_wscale : 4; /// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; @$pb.TagNumber(1207) - $core.int get tcpInfoSendScale => $_getIZ(70); + $core.int get tcpInfoSendScale => $_getIZ(71); @$pb.TagNumber(1207) - set tcpInfoSendScale($core.int value) => $_setUnsignedInt32(70, value); + set tcpInfoSendScale($core.int value) => $_setUnsignedInt32(71, value); @$pb.TagNumber(1207) - $core.bool hasTcpInfoSendScale() => $_has(70); + $core.bool hasTcpInfoSendScale() => $_has(71); @$pb.TagNumber(1207) void clearTcpInfoSendScale() => $_clearField(1207); @$pb.TagNumber(1208) - $core.int get tcpInfoRcvScale => $_getIZ(71); + $core.int get tcpInfoRcvScale => $_getIZ(72); @$pb.TagNumber(1208) - set tcpInfoRcvScale($core.int value) => $_setUnsignedInt32(71, value); + set tcpInfoRcvScale($core.int value) => $_setUnsignedInt32(72, value); @$pb.TagNumber(1208) - $core.bool hasTcpInfoRcvScale() => $_has(71); + $core.bool hasTcpInfoRcvScale() => $_has(72); @$pb.TagNumber(1208) void clearTcpInfoRcvScale() => $_clearField(1208); @$pb.TagNumber(1209) - $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(72); + $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(73); @$pb.TagNumber(1209) set tcpInfoDeliveryRateAppLimited($core.int value) => - $_setUnsignedInt32(72, value); + $_setUnsignedInt32(73, value); @$pb.TagNumber(1209) - $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(72); + $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(73); @$pb.TagNumber(1209) void clearTcpInfoDeliveryRateAppLimited() => $_clearField(1209); @$pb.TagNumber(1210) - $core.int get tcpInfoFastOpenClientFailed => $_getIZ(73); + $core.int get tcpInfoFastOpenClientFailed => $_getIZ(74); @$pb.TagNumber(1210) set tcpInfoFastOpenClientFailed($core.int value) => - $_setUnsignedInt32(73, value); + $_setUnsignedInt32(74, value); @$pb.TagNumber(1210) - $core.bool hasTcpInfoFastOpenClientFailed() => $_has(73); + $core.bool hasTcpInfoFastOpenClientFailed() => $_has(74); @$pb.TagNumber(1210) void clearTcpInfoFastOpenClientFailed() => $_clearField(1210); @$pb.TagNumber(1215) - $core.int get tcpInfoRto => $_getIZ(74); + $core.int get tcpInfoRto => $_getIZ(75); @$pb.TagNumber(1215) - set tcpInfoRto($core.int value) => $_setUnsignedInt32(74, value); + set tcpInfoRto($core.int value) => $_setUnsignedInt32(75, value); @$pb.TagNumber(1215) - $core.bool hasTcpInfoRto() => $_has(74); + $core.bool hasTcpInfoRto() => $_has(75); @$pb.TagNumber(1215) void clearTcpInfoRto() => $_clearField(1215); @$pb.TagNumber(1216) - $core.int get tcpInfoAto => $_getIZ(75); + $core.int get tcpInfoAto => $_getIZ(76); @$pb.TagNumber(1216) - set tcpInfoAto($core.int value) => $_setUnsignedInt32(75, value); + set tcpInfoAto($core.int value) => $_setUnsignedInt32(76, value); @$pb.TagNumber(1216) - $core.bool hasTcpInfoAto() => $_has(75); + $core.bool hasTcpInfoAto() => $_has(76); @$pb.TagNumber(1216) void clearTcpInfoAto() => $_clearField(1216); @$pb.TagNumber(1217) - $core.int get tcpInfoSndMss => $_getIZ(76); + $core.int get tcpInfoSndMss => $_getIZ(77); @$pb.TagNumber(1217) - set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(76, value); + set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(77, value); @$pb.TagNumber(1217) - $core.bool hasTcpInfoSndMss() => $_has(76); + $core.bool hasTcpInfoSndMss() => $_has(77); @$pb.TagNumber(1217) void clearTcpInfoSndMss() => $_clearField(1217); @$pb.TagNumber(1218) - $core.int get tcpInfoRcvMss => $_getIZ(77); + $core.int get tcpInfoRcvMss => $_getIZ(78); @$pb.TagNumber(1218) - set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(77, value); + set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(78, value); @$pb.TagNumber(1218) - $core.bool hasTcpInfoRcvMss() => $_has(77); + $core.bool hasTcpInfoRcvMss() => $_has(78); @$pb.TagNumber(1218) void clearTcpInfoRcvMss() => $_clearField(1218); @$pb.TagNumber(1219) - $core.int get tcpInfoUnacked => $_getIZ(78); + $core.int get tcpInfoUnacked => $_getIZ(79); @$pb.TagNumber(1219) - set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(78, value); + set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(79, value); @$pb.TagNumber(1219) - $core.bool hasTcpInfoUnacked() => $_has(78); + $core.bool hasTcpInfoUnacked() => $_has(79); @$pb.TagNumber(1219) void clearTcpInfoUnacked() => $_clearField(1219); @$pb.TagNumber(1220) - $core.int get tcpInfoSacked => $_getIZ(79); + $core.int get tcpInfoSacked => $_getIZ(80); @$pb.TagNumber(1220) - set tcpInfoSacked($core.int value) => $_setUnsignedInt32(79, value); + set tcpInfoSacked($core.int value) => $_setUnsignedInt32(80, value); @$pb.TagNumber(1220) - $core.bool hasTcpInfoSacked() => $_has(79); + $core.bool hasTcpInfoSacked() => $_has(80); @$pb.TagNumber(1220) void clearTcpInfoSacked() => $_clearField(1220); @$pb.TagNumber(1221) - $core.int get tcpInfoLost => $_getIZ(80); + $core.int get tcpInfoLost => $_getIZ(81); @$pb.TagNumber(1221) - set tcpInfoLost($core.int value) => $_setUnsignedInt32(80, value); + set tcpInfoLost($core.int value) => $_setUnsignedInt32(81, value); @$pb.TagNumber(1221) - $core.bool hasTcpInfoLost() => $_has(80); + $core.bool hasTcpInfoLost() => $_has(81); @$pb.TagNumber(1221) void clearTcpInfoLost() => $_clearField(1221); @$pb.TagNumber(1222) - $core.int get tcpInfoRetrans => $_getIZ(81); + $core.int get tcpInfoRetrans => $_getIZ(82); @$pb.TagNumber(1222) - set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(81, value); + set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(82, value); @$pb.TagNumber(1222) - $core.bool hasTcpInfoRetrans() => $_has(81); + $core.bool hasTcpInfoRetrans() => $_has(82); @$pb.TagNumber(1222) void clearTcpInfoRetrans() => $_clearField(1222); @$pb.TagNumber(1223) - $core.int get tcpInfoFackets => $_getIZ(82); + $core.int get tcpInfoFackets => $_getIZ(83); @$pb.TagNumber(1223) - set tcpInfoFackets($core.int value) => $_setUnsignedInt32(82, value); + set tcpInfoFackets($core.int value) => $_setUnsignedInt32(83, value); @$pb.TagNumber(1223) - $core.bool hasTcpInfoFackets() => $_has(82); + $core.bool hasTcpInfoFackets() => $_has(83); @$pb.TagNumber(1223) void clearTcpInfoFackets() => $_clearField(1223); /// Times @$pb.TagNumber(1224) - $core.int get tcpInfoLastDataSent => $_getIZ(83); + $core.int get tcpInfoLastDataSent => $_getIZ(84); @$pb.TagNumber(1224) - set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(83, value); + set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(84, value); @$pb.TagNumber(1224) - $core.bool hasTcpInfoLastDataSent() => $_has(83); + $core.bool hasTcpInfoLastDataSent() => $_has(84); @$pb.TagNumber(1224) void clearTcpInfoLastDataSent() => $_clearField(1224); @$pb.TagNumber(1225) - $core.int get tcpInfoLastAckSent => $_getIZ(84); + $core.int get tcpInfoLastAckSent => $_getIZ(85); @$pb.TagNumber(1225) - set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(84, value); + set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(85, value); @$pb.TagNumber(1225) - $core.bool hasTcpInfoLastAckSent() => $_has(84); + $core.bool hasTcpInfoLastAckSent() => $_has(85); @$pb.TagNumber(1225) void clearTcpInfoLastAckSent() => $_clearField(1225); @$pb.TagNumber(1226) - $core.int get tcpInfoLastDataRecv => $_getIZ(85); + $core.int get tcpInfoLastDataRecv => $_getIZ(86); @$pb.TagNumber(1226) - set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(85, value); + set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(86, value); @$pb.TagNumber(1226) - $core.bool hasTcpInfoLastDataRecv() => $_has(85); + $core.bool hasTcpInfoLastDataRecv() => $_has(86); @$pb.TagNumber(1226) void clearTcpInfoLastDataRecv() => $_clearField(1226); @$pb.TagNumber(1227) - $core.int get tcpInfoLastAckRecv => $_getIZ(86); + $core.int get tcpInfoLastAckRecv => $_getIZ(87); @$pb.TagNumber(1227) - set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(86, value); + set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(87, value); @$pb.TagNumber(1227) - $core.bool hasTcpInfoLastAckRecv() => $_has(86); + $core.bool hasTcpInfoLastAckRecv() => $_has(87); @$pb.TagNumber(1227) void clearTcpInfoLastAckRecv() => $_clearField(1227); /// Metrics @$pb.TagNumber(1228) - $core.int get tcpInfoPmtu => $_getIZ(87); + $core.int get tcpInfoPmtu => $_getIZ(88); @$pb.TagNumber(1228) - set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(87, value); + set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(88, value); @$pb.TagNumber(1228) - $core.bool hasTcpInfoPmtu() => $_has(87); + $core.bool hasTcpInfoPmtu() => $_has(88); @$pb.TagNumber(1228) void clearTcpInfoPmtu() => $_clearField(1228); @$pb.TagNumber(1229) - $core.int get tcpInfoRcvSsthresh => $_getIZ(88); + $core.int get tcpInfoRcvSsthresh => $_getIZ(89); @$pb.TagNumber(1229) - set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(88, value); + set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(89, value); @$pb.TagNumber(1229) - $core.bool hasTcpInfoRcvSsthresh() => $_has(88); + $core.bool hasTcpInfoRcvSsthresh() => $_has(89); @$pb.TagNumber(1229) void clearTcpInfoRcvSsthresh() => $_clearField(1229); @$pb.TagNumber(1230) - $core.int get tcpInfoRtt => $_getIZ(89); + $core.int get tcpInfoRtt => $_getIZ(90); @$pb.TagNumber(1230) - set tcpInfoRtt($core.int value) => $_setUnsignedInt32(89, value); + set tcpInfoRtt($core.int value) => $_setUnsignedInt32(90, value); @$pb.TagNumber(1230) - $core.bool hasTcpInfoRtt() => $_has(89); + $core.bool hasTcpInfoRtt() => $_has(90); @$pb.TagNumber(1230) void clearTcpInfoRtt() => $_clearField(1230); @$pb.TagNumber(1231) - $core.int get tcpInfoRttVar => $_getIZ(90); + $core.int get tcpInfoRttVar => $_getIZ(91); @$pb.TagNumber(1231) - set tcpInfoRttVar($core.int value) => $_setUnsignedInt32(90, value); + set tcpInfoRttVar($core.int value) => $_setUnsignedInt32(91, value); @$pb.TagNumber(1231) - $core.bool hasTcpInfoRttVar() => $_has(90); + $core.bool hasTcpInfoRttVar() => $_has(91); @$pb.TagNumber(1231) void clearTcpInfoRttVar() => $_clearField(1231); @$pb.TagNumber(1232) - $core.int get tcpInfoSndSsthresh => $_getIZ(91); + $core.int get tcpInfoSndSsthresh => $_getIZ(92); @$pb.TagNumber(1232) - set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(91, value); + set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(92, value); @$pb.TagNumber(1232) - $core.bool hasTcpInfoSndSsthresh() => $_has(91); + $core.bool hasTcpInfoSndSsthresh() => $_has(92); @$pb.TagNumber(1232) void clearTcpInfoSndSsthresh() => $_clearField(1232); @$pb.TagNumber(1233) - $core.int get tcpInfoSndCwnd => $_getIZ(92); + $core.int get tcpInfoSndCwnd => $_getIZ(93); @$pb.TagNumber(1233) - set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(92, value); + set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(93, value); @$pb.TagNumber(1233) - $core.bool hasTcpInfoSndCwnd() => $_has(92); + $core.bool hasTcpInfoSndCwnd() => $_has(93); @$pb.TagNumber(1233) void clearTcpInfoSndCwnd() => $_clearField(1233); @$pb.TagNumber(1234) - $core.int get tcpInfoAdvMss => $_getIZ(93); + $core.int get tcpInfoAdvMss => $_getIZ(94); @$pb.TagNumber(1234) - set tcpInfoAdvMss($core.int value) => $_setUnsignedInt32(93, value); + set tcpInfoAdvMss($core.int value) => $_setUnsignedInt32(94, value); @$pb.TagNumber(1234) - $core.bool hasTcpInfoAdvMss() => $_has(93); + $core.bool hasTcpInfoAdvMss() => $_has(94); @$pb.TagNumber(1234) void clearTcpInfoAdvMss() => $_clearField(1234); @$pb.TagNumber(1235) - $core.int get tcpInfoReordering => $_getIZ(94); + $core.int get tcpInfoReordering => $_getIZ(95); @$pb.TagNumber(1235) - set tcpInfoReordering($core.int value) => $_setUnsignedInt32(94, value); + set tcpInfoReordering($core.int value) => $_setUnsignedInt32(95, value); @$pb.TagNumber(1235) - $core.bool hasTcpInfoReordering() => $_has(94); + $core.bool hasTcpInfoReordering() => $_has(95); @$pb.TagNumber(1235) void clearTcpInfoReordering() => $_clearField(1235); @$pb.TagNumber(1236) - $core.int get tcpInfoRcvRtt => $_getIZ(95); + $core.int get tcpInfoRcvRtt => $_getIZ(96); @$pb.TagNumber(1236) - set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(95, value); + set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(96, value); @$pb.TagNumber(1236) - $core.bool hasTcpInfoRcvRtt() => $_has(95); + $core.bool hasTcpInfoRcvRtt() => $_has(96); @$pb.TagNumber(1236) void clearTcpInfoRcvRtt() => $_clearField(1236); @$pb.TagNumber(1237) - $core.int get tcpInfoRcvSpace => $_getIZ(96); + $core.int get tcpInfoRcvSpace => $_getIZ(97); @$pb.TagNumber(1237) - set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(96, value); + set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(97, value); @$pb.TagNumber(1237) - $core.bool hasTcpInfoRcvSpace() => $_has(96); + $core.bool hasTcpInfoRcvSpace() => $_has(97); @$pb.TagNumber(1237) void clearTcpInfoRcvSpace() => $_clearField(1237); @$pb.TagNumber(1238) - $core.int get tcpInfoTotalRetrans => $_getIZ(97); + $core.int get tcpInfoTotalRetrans => $_getIZ(98); @$pb.TagNumber(1238) - set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(97, value); + set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(98, value); @$pb.TagNumber(1238) - $core.bool hasTcpInfoTotalRetrans() => $_has(97); + $core.bool hasTcpInfoTotalRetrans() => $_has(98); @$pb.TagNumber(1238) void clearTcpInfoTotalRetrans() => $_clearField(1238); @$pb.TagNumber(1239) - $fixnum.Int64 get tcpInfoPacingRate => $_getI64(98); + $fixnum.Int64 get tcpInfoPacingRate => $_getI64(99); @$pb.TagNumber(1239) - set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(98, value); + set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(99, value); @$pb.TagNumber(1239) - $core.bool hasTcpInfoPacingRate() => $_has(98); + $core.bool hasTcpInfoPacingRate() => $_has(99); @$pb.TagNumber(1239) void clearTcpInfoPacingRate() => $_clearField(1239); @$pb.TagNumber(1240) - $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(99); + $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(100); @$pb.TagNumber(1240) - set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(99, value); + set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(100, value); @$pb.TagNumber(1240) - $core.bool hasTcpInfoMaxPacingRate() => $_has(99); + $core.bool hasTcpInfoMaxPacingRate() => $_has(100); @$pb.TagNumber(1240) void clearTcpInfoMaxPacingRate() => $_clearField(1240); @$pb.TagNumber(1241) - $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(100); + $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(101); @$pb.TagNumber(1241) - set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(100, value); + set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(101, value); @$pb.TagNumber(1241) - $core.bool hasTcpInfoBytesAcked() => $_has(100); + $core.bool hasTcpInfoBytesAcked() => $_has(101); @$pb.TagNumber(1241) void clearTcpInfoBytesAcked() => $_clearField(1241); @$pb.TagNumber(1242) - $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(101); + $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(102); @$pb.TagNumber(1242) - set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(101, value); + set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(102, value); @$pb.TagNumber(1242) - $core.bool hasTcpInfoBytesReceived() => $_has(101); + $core.bool hasTcpInfoBytesReceived() => $_has(102); @$pb.TagNumber(1242) void clearTcpInfoBytesReceived() => $_clearField(1242); @$pb.TagNumber(1243) - $core.int get tcpInfoSegsOut => $_getIZ(102); + $core.int get tcpInfoSegsOut => $_getIZ(103); @$pb.TagNumber(1243) - set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(102, value); + set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(103, value); @$pb.TagNumber(1243) - $core.bool hasTcpInfoSegsOut() => $_has(102); + $core.bool hasTcpInfoSegsOut() => $_has(103); @$pb.TagNumber(1243) void clearTcpInfoSegsOut() => $_clearField(1243); @$pb.TagNumber(1244) - $core.int get tcpInfoSegsIn => $_getIZ(103); + $core.int get tcpInfoSegsIn => $_getIZ(104); @$pb.TagNumber(1244) - set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(103, value); + set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(104, value); @$pb.TagNumber(1244) - $core.bool hasTcpInfoSegsIn() => $_has(103); + $core.bool hasTcpInfoSegsIn() => $_has(104); @$pb.TagNumber(1244) void clearTcpInfoSegsIn() => $_clearField(1244); @$pb.TagNumber(1245) - $core.int get tcpInfoNotSentBytes => $_getIZ(104); + $core.int get tcpInfoNotSentBytes => $_getIZ(105); @$pb.TagNumber(1245) - set tcpInfoNotSentBytes($core.int value) => $_setUnsignedInt32(104, value); + set tcpInfoNotSentBytes($core.int value) => $_setUnsignedInt32(105, value); @$pb.TagNumber(1245) - $core.bool hasTcpInfoNotSentBytes() => $_has(104); + $core.bool hasTcpInfoNotSentBytes() => $_has(105); @$pb.TagNumber(1245) void clearTcpInfoNotSentBytes() => $_clearField(1245); @$pb.TagNumber(1246) - $core.int get tcpInfoMinRtt => $_getIZ(105); + $core.int get tcpInfoMinRtt => $_getIZ(106); @$pb.TagNumber(1246) - set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(105, value); + set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(106, value); @$pb.TagNumber(1246) - $core.bool hasTcpInfoMinRtt() => $_has(105); + $core.bool hasTcpInfoMinRtt() => $_has(106); @$pb.TagNumber(1246) void clearTcpInfoMinRtt() => $_clearField(1246); @$pb.TagNumber(1247) - $core.int get tcpInfoDataSegsIn => $_getIZ(106); + $core.int get tcpInfoDataSegsIn => $_getIZ(107); @$pb.TagNumber(1247) - set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(106, value); + set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(107, value); @$pb.TagNumber(1247) - $core.bool hasTcpInfoDataSegsIn() => $_has(106); + $core.bool hasTcpInfoDataSegsIn() => $_has(107); @$pb.TagNumber(1247) void clearTcpInfoDataSegsIn() => $_clearField(1247); @$pb.TagNumber(1248) - $core.int get tcpInfoDataSegsOut => $_getIZ(107); + $core.int get tcpInfoDataSegsOut => $_getIZ(108); @$pb.TagNumber(1248) - set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(107, value); + set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(108, value); @$pb.TagNumber(1248) - $core.bool hasTcpInfoDataSegsOut() => $_has(107); + $core.bool hasTcpInfoDataSegsOut() => $_has(108); @$pb.TagNumber(1248) void clearTcpInfoDataSegsOut() => $_clearField(1248); @$pb.TagNumber(1249) - $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(108); + $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(109); @$pb.TagNumber(1249) - set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(108, value); + set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(109, value); @$pb.TagNumber(1249) - $core.bool hasTcpInfoDeliveryRate() => $_has(108); + $core.bool hasTcpInfoDeliveryRate() => $_has(109); @$pb.TagNumber(1249) void clearTcpInfoDeliveryRate() => $_clearField(1249); @$pb.TagNumber(1250) - $fixnum.Int64 get tcpInfoBusyTime => $_getI64(109); + $fixnum.Int64 get tcpInfoBusyTime => $_getI64(110); @$pb.TagNumber(1250) - set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(109, value); + set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(110, value); @$pb.TagNumber(1250) - $core.bool hasTcpInfoBusyTime() => $_has(109); + $core.bool hasTcpInfoBusyTime() => $_has(110); @$pb.TagNumber(1250) void clearTcpInfoBusyTime() => $_clearField(1250); @$pb.TagNumber(1251) - $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(110); + $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(111); @$pb.TagNumber(1251) - set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(110, value); + set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(111, value); @$pb.TagNumber(1251) - $core.bool hasTcpInfoRwndLimited() => $_has(110); + $core.bool hasTcpInfoRwndLimited() => $_has(111); @$pb.TagNumber(1251) void clearTcpInfoRwndLimited() => $_clearField(1251); @$pb.TagNumber(1252) - $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(111); + $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(112); @$pb.TagNumber(1252) - set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(111, value); + set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(112, value); @$pb.TagNumber(1252) - $core.bool hasTcpInfoSndbufLimited() => $_has(111); + $core.bool hasTcpInfoSndbufLimited() => $_has(112); @$pb.TagNumber(1252) void clearTcpInfoSndbufLimited() => $_clearField(1252); @$pb.TagNumber(1253) - $core.int get tcpInfoDelivered => $_getIZ(112); + $core.int get tcpInfoDelivered => $_getIZ(113); @$pb.TagNumber(1253) - set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(112, value); + set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(113, value); @$pb.TagNumber(1253) - $core.bool hasTcpInfoDelivered() => $_has(112); + $core.bool hasTcpInfoDelivered() => $_has(113); @$pb.TagNumber(1253) void clearTcpInfoDelivered() => $_clearField(1253); @$pb.TagNumber(1254) - $core.int get tcpInfoDeliveredCe => $_getIZ(113); + $core.int get tcpInfoDeliveredCe => $_getIZ(114); @$pb.TagNumber(1254) - set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(113, value); + set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(114, value); @$pb.TagNumber(1254) - $core.bool hasTcpInfoDeliveredCe() => $_has(113); + $core.bool hasTcpInfoDeliveredCe() => $_has(114); @$pb.TagNumber(1254) void clearTcpInfoDeliveredCe() => $_clearField(1254); /// https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB @$pb.TagNumber(1255) - $fixnum.Int64 get tcpInfoBytesSent => $_getI64(114); + $fixnum.Int64 get tcpInfoBytesSent => $_getI64(115); @$pb.TagNumber(1255) - set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(114, value); + set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(115, value); @$pb.TagNumber(1255) - $core.bool hasTcpInfoBytesSent() => $_has(114); + $core.bool hasTcpInfoBytesSent() => $_has(115); @$pb.TagNumber(1255) void clearTcpInfoBytesSent() => $_clearField(1255); @$pb.TagNumber(1256) - $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(115); + $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(116); @$pb.TagNumber(1256) - set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(115, value); + set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(116, value); @$pb.TagNumber(1256) - $core.bool hasTcpInfoBytesRetrans() => $_has(115); + $core.bool hasTcpInfoBytesRetrans() => $_has(116); @$pb.TagNumber(1256) void clearTcpInfoBytesRetrans() => $_clearField(1256); @$pb.TagNumber(1257) - $core.int get tcpInfoDsackDups => $_getIZ(116); + $core.int get tcpInfoDsackDups => $_getIZ(117); @$pb.TagNumber(1257) - set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(116, value); + set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(117, value); @$pb.TagNumber(1257) - $core.bool hasTcpInfoDsackDups() => $_has(116); + $core.bool hasTcpInfoDsackDups() => $_has(117); @$pb.TagNumber(1257) void clearTcpInfoDsackDups() => $_clearField(1257); @$pb.TagNumber(1258) - $core.int get tcpInfoReordSeen => $_getIZ(117); + $core.int get tcpInfoReordSeen => $_getIZ(118); @$pb.TagNumber(1258) - set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(117, value); + set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(118, value); @$pb.TagNumber(1258) - $core.bool hasTcpInfoReordSeen() => $_has(117); + $core.bool hasTcpInfoReordSeen() => $_has(118); @$pb.TagNumber(1258) void clearTcpInfoReordSeen() => $_clearField(1258); @$pb.TagNumber(1259) - $core.int get tcpInfoRcvOoopack => $_getIZ(118); + $core.int get tcpInfoRcvOoopack => $_getIZ(119); @$pb.TagNumber(1259) - set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(118, value); + set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(119, value); @$pb.TagNumber(1259) - $core.bool hasTcpInfoRcvOoopack() => $_has(118); + $core.bool hasTcpInfoRcvOoopack() => $_has(119); @$pb.TagNumber(1259) void clearTcpInfoRcvOoopack() => $_clearField(1259); @$pb.TagNumber(1260) - $core.int get tcpInfoSndWnd => $_getIZ(119); + $core.int get tcpInfoSndWnd => $_getIZ(120); @$pb.TagNumber(1260) - set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(119, value); + set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(120, value); @$pb.TagNumber(1260) - $core.bool hasTcpInfoSndWnd() => $_has(119); + $core.bool hasTcpInfoSndWnd() => $_has(120); @$pb.TagNumber(1260) void clearTcpInfoSndWnd() => $_clearField(1260); @$pb.TagNumber(1261) - $core.int get tcpInfoRcvWnd => $_getIZ(120); + $core.int get tcpInfoRcvWnd => $_getIZ(121); @$pb.TagNumber(1261) - set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(120, value); + set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(121, value); @$pb.TagNumber(1261) - $core.bool hasTcpInfoRcvWnd() => $_has(120); + $core.bool hasTcpInfoRcvWnd() => $_has(121); @$pb.TagNumber(1261) void clearTcpInfoRcvWnd() => $_clearField(1261); @$pb.TagNumber(1262) - $core.int get tcpInfoRehash => $_getIZ(121); + $core.int get tcpInfoRehash => $_getIZ(122); @$pb.TagNumber(1262) - set tcpInfoRehash($core.int value) => $_setUnsignedInt32(121, value); + set tcpInfoRehash($core.int value) => $_setUnsignedInt32(122, value); @$pb.TagNumber(1262) - $core.bool hasTcpInfoRehash() => $_has(121); + $core.bool hasTcpInfoRehash() => $_has(122); @$pb.TagNumber(1262) void clearTcpInfoRehash() => $_clearField(1262); @$pb.TagNumber(1263) - $core.int get tcpInfoTotalRto => $_getIZ(122); + $core.int get tcpInfoTotalRto => $_getIZ(123); @$pb.TagNumber(1263) - set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(122, value); + set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(123, value); @$pb.TagNumber(1263) - $core.bool hasTcpInfoTotalRto() => $_has(122); + $core.bool hasTcpInfoTotalRto() => $_has(123); @$pb.TagNumber(1263) void clearTcpInfoTotalRto() => $_clearField(1263); @$pb.TagNumber(1264) - $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(123); + $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(124); @$pb.TagNumber(1264) set tcpInfoTotalRtoRecoveries($core.int value) => - $_setUnsignedInt32(123, value); + $_setUnsignedInt32(124, value); @$pb.TagNumber(1264) - $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(123); + $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(124); @$pb.TagNumber(1264) void clearTcpInfoTotalRtoRecoveries() => $_clearField(1264); @$pb.TagNumber(1265) - $core.int get tcpInfoTotalRtoTime => $_getIZ(124); + $core.int get tcpInfoTotalRtoTime => $_getIZ(125); @$pb.TagNumber(1265) - set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(124, value); + set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(125, value); @$pb.TagNumber(1265) - $core.bool hasTcpInfoTotalRtoTime() => $_has(124); + $core.bool hasTcpInfoTotalRtoTime() => $_has(125); @$pb.TagNumber(1265) void clearTcpInfoTotalRtoTime() => $_clearField(1265); @@ -1980,282 +1999,282 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// just in case we need to quickly put a different algorithm in without updating the enum. /// Obviously it's optional, so it low cost. @$pb.TagNumber(1300) - $core.String get congestionAlgorithmString => $_getSZ(125); + $core.String get congestionAlgorithmString => $_getSZ(126); @$pb.TagNumber(1300) - set congestionAlgorithmString($core.String value) => $_setString(125, value); + set congestionAlgorithmString($core.String value) => $_setString(126, value); @$pb.TagNumber(1300) - $core.bool hasCongestionAlgorithmString() => $_has(125); + $core.bool hasCongestionAlgorithmString() => $_has(126); @$pb.TagNumber(1300) void clearCongestionAlgorithmString() => $_clearField(1300); @$pb.TagNumber(1301) - XtcpFlatRecord_CongestionAlgorithm get congestionAlgorithmEnum => $_getN(126); + XtcpFlatRecord_CongestionAlgorithm get congestionAlgorithmEnum => $_getN(127); @$pb.TagNumber(1301) set congestionAlgorithmEnum(XtcpFlatRecord_CongestionAlgorithm value) => $_setField(1301, value); @$pb.TagNumber(1301) - $core.bool hasCongestionAlgorithmEnum() => $_has(126); + $core.bool hasCongestionAlgorithmEnum() => $_has(127); @$pb.TagNumber(1301) void clearCongestionAlgorithmEnum() => $_clearField(1301); @$pb.TagNumber(1401) - $core.int get typeOfService => $_getIZ(127); + $core.int get typeOfService => $_getIZ(128); @$pb.TagNumber(1401) - set typeOfService($core.int value) => $_setUnsignedInt32(127, value); + set typeOfService($core.int value) => $_setUnsignedInt32(128, value); @$pb.TagNumber(1401) - $core.bool hasTypeOfService() => $_has(127); + $core.bool hasTypeOfService() => $_has(128); @$pb.TagNumber(1401) void clearTypeOfService() => $_clearField(1401); @$pb.TagNumber(1402) - $core.int get trafficClass => $_getIZ(128); + $core.int get trafficClass => $_getIZ(129); @$pb.TagNumber(1402) - set trafficClass($core.int value) => $_setUnsignedInt32(128, value); + set trafficClass($core.int value) => $_setUnsignedInt32(129, value); @$pb.TagNumber(1402) - $core.bool hasTrafficClass() => $_has(128); + $core.bool hasTrafficClass() => $_has(129); @$pb.TagNumber(1402) void clearTrafficClass() => $_clearField(1402); @$pb.TagNumber(1501) - $core.int get skMemInfoRmemAlloc => $_getIZ(129); + $core.int get skMemInfoRmemAlloc => $_getIZ(130); @$pb.TagNumber(1501) - set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(129, value); + set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(130, value); @$pb.TagNumber(1501) - $core.bool hasSkMemInfoRmemAlloc() => $_has(129); + $core.bool hasSkMemInfoRmemAlloc() => $_has(130); @$pb.TagNumber(1501) void clearSkMemInfoRmemAlloc() => $_clearField(1501); @$pb.TagNumber(1502) - $core.int get skMemInfoRcvBuf => $_getIZ(130); + $core.int get skMemInfoRcvBuf => $_getIZ(131); @$pb.TagNumber(1502) - set skMemInfoRcvBuf($core.int value) => $_setUnsignedInt32(130, value); + set skMemInfoRcvBuf($core.int value) => $_setUnsignedInt32(131, value); @$pb.TagNumber(1502) - $core.bool hasSkMemInfoRcvBuf() => $_has(130); + $core.bool hasSkMemInfoRcvBuf() => $_has(131); @$pb.TagNumber(1502) void clearSkMemInfoRcvBuf() => $_clearField(1502); @$pb.TagNumber(1503) - $core.int get skMemInfoWmemAlloc => $_getIZ(131); + $core.int get skMemInfoWmemAlloc => $_getIZ(132); @$pb.TagNumber(1503) - set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(131, value); + set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(132, value); @$pb.TagNumber(1503) - $core.bool hasSkMemInfoWmemAlloc() => $_has(131); + $core.bool hasSkMemInfoWmemAlloc() => $_has(132); @$pb.TagNumber(1503) void clearSkMemInfoWmemAlloc() => $_clearField(1503); @$pb.TagNumber(1504) - $core.int get skMemInfoSndBuf => $_getIZ(132); + $core.int get skMemInfoSndBuf => $_getIZ(133); @$pb.TagNumber(1504) - set skMemInfoSndBuf($core.int value) => $_setUnsignedInt32(132, value); + set skMemInfoSndBuf($core.int value) => $_setUnsignedInt32(133, value); @$pb.TagNumber(1504) - $core.bool hasSkMemInfoSndBuf() => $_has(132); + $core.bool hasSkMemInfoSndBuf() => $_has(133); @$pb.TagNumber(1504) void clearSkMemInfoSndBuf() => $_clearField(1504); @$pb.TagNumber(1505) - $core.int get skMemInfoFwdAlloc => $_getIZ(133); + $core.int get skMemInfoFwdAlloc => $_getIZ(134); @$pb.TagNumber(1505) - set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(133, value); + set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(134, value); @$pb.TagNumber(1505) - $core.bool hasSkMemInfoFwdAlloc() => $_has(133); + $core.bool hasSkMemInfoFwdAlloc() => $_has(134); @$pb.TagNumber(1505) void clearSkMemInfoFwdAlloc() => $_clearField(1505); @$pb.TagNumber(1506) - $core.int get skMemInfoWmemQueued => $_getIZ(134); + $core.int get skMemInfoWmemQueued => $_getIZ(135); @$pb.TagNumber(1506) - set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(134, value); + set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(135, value); @$pb.TagNumber(1506) - $core.bool hasSkMemInfoWmemQueued() => $_has(134); + $core.bool hasSkMemInfoWmemQueued() => $_has(135); @$pb.TagNumber(1506) void clearSkMemInfoWmemQueued() => $_clearField(1506); @$pb.TagNumber(1507) - $core.int get skMemInfoOptmem => $_getIZ(135); + $core.int get skMemInfoOptmem => $_getIZ(136); @$pb.TagNumber(1507) - set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(135, value); + set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(136, value); @$pb.TagNumber(1507) - $core.bool hasSkMemInfoOptmem() => $_has(135); + $core.bool hasSkMemInfoOptmem() => $_has(136); @$pb.TagNumber(1507) void clearSkMemInfoOptmem() => $_clearField(1507); @$pb.TagNumber(1508) - $core.int get skMemInfoBacklog => $_getIZ(136); + $core.int get skMemInfoBacklog => $_getIZ(137); @$pb.TagNumber(1508) - set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(136, value); + set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(137, value); @$pb.TagNumber(1508) - $core.bool hasSkMemInfoBacklog() => $_has(136); + $core.bool hasSkMemInfoBacklog() => $_has(137); @$pb.TagNumber(1508) void clearSkMemInfoBacklog() => $_clearField(1508); @$pb.TagNumber(1509) - $core.int get skMemInfoDrops => $_getIZ(137); + $core.int get skMemInfoDrops => $_getIZ(138); @$pb.TagNumber(1509) - set skMemInfoDrops($core.int value) => $_setUnsignedInt32(137, value); + set skMemInfoDrops($core.int value) => $_setUnsignedInt32(138, value); @$pb.TagNumber(1509) - $core.bool hasSkMemInfoDrops() => $_has(137); + $core.bool hasSkMemInfoDrops() => $_has(138); @$pb.TagNumber(1509) void clearSkMemInfoDrops() => $_clearField(1509); @$pb.TagNumber(1600) - $core.int get shutdownState => $_getIZ(138); + $core.int get shutdownState => $_getIZ(139); @$pb.TagNumber(1600) - set shutdownState($core.int value) => $_setUnsignedInt32(138, value); + set shutdownState($core.int value) => $_setUnsignedInt32(139, value); @$pb.TagNumber(1600) - $core.bool hasShutdownState() => $_has(138); + $core.bool hasShutdownState() => $_has(139); @$pb.TagNumber(1600) void clearShutdownState() => $_clearField(1600); @$pb.TagNumber(1701) - $core.int get vegasInfoEnabled => $_getIZ(139); + $core.int get vegasInfoEnabled => $_getIZ(140); @$pb.TagNumber(1701) - set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(139, value); + set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(140, value); @$pb.TagNumber(1701) - $core.bool hasVegasInfoEnabled() => $_has(139); + $core.bool hasVegasInfoEnabled() => $_has(140); @$pb.TagNumber(1701) void clearVegasInfoEnabled() => $_clearField(1701); @$pb.TagNumber(1702) - $core.int get vegasInfoRttCnt => $_getIZ(140); + $core.int get vegasInfoRttCnt => $_getIZ(141); @$pb.TagNumber(1702) - set vegasInfoRttCnt($core.int value) => $_setUnsignedInt32(140, value); + set vegasInfoRttCnt($core.int value) => $_setUnsignedInt32(141, value); @$pb.TagNumber(1702) - $core.bool hasVegasInfoRttCnt() => $_has(140); + $core.bool hasVegasInfoRttCnt() => $_has(141); @$pb.TagNumber(1702) void clearVegasInfoRttCnt() => $_clearField(1702); @$pb.TagNumber(1703) - $core.int get vegasInfoRtt => $_getIZ(141); + $core.int get vegasInfoRtt => $_getIZ(142); @$pb.TagNumber(1703) - set vegasInfoRtt($core.int value) => $_setUnsignedInt32(141, value); + set vegasInfoRtt($core.int value) => $_setUnsignedInt32(142, value); @$pb.TagNumber(1703) - $core.bool hasVegasInfoRtt() => $_has(141); + $core.bool hasVegasInfoRtt() => $_has(142); @$pb.TagNumber(1703) void clearVegasInfoRtt() => $_clearField(1703); @$pb.TagNumber(1704) - $core.int get vegasInfoMinRtt => $_getIZ(142); + $core.int get vegasInfoMinRtt => $_getIZ(143); @$pb.TagNumber(1704) - set vegasInfoMinRtt($core.int value) => $_setUnsignedInt32(142, value); + set vegasInfoMinRtt($core.int value) => $_setUnsignedInt32(143, value); @$pb.TagNumber(1704) - $core.bool hasVegasInfoMinRtt() => $_has(142); + $core.bool hasVegasInfoMinRtt() => $_has(143); @$pb.TagNumber(1704) void clearVegasInfoMinRtt() => $_clearField(1704); @$pb.TagNumber(1801) - $core.int get dctcpInfoEnabled => $_getIZ(143); + $core.int get dctcpInfoEnabled => $_getIZ(144); @$pb.TagNumber(1801) - set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(143, value); + set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(144, value); @$pb.TagNumber(1801) - $core.bool hasDctcpInfoEnabled() => $_has(143); + $core.bool hasDctcpInfoEnabled() => $_has(144); @$pb.TagNumber(1801) void clearDctcpInfoEnabled() => $_clearField(1801); @$pb.TagNumber(1802) - $core.int get dctcpInfoCeState => $_getIZ(144); + $core.int get dctcpInfoCeState => $_getIZ(145); @$pb.TagNumber(1802) - set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(144, value); + set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(145, value); @$pb.TagNumber(1802) - $core.bool hasDctcpInfoCeState() => $_has(144); + $core.bool hasDctcpInfoCeState() => $_has(145); @$pb.TagNumber(1802) void clearDctcpInfoCeState() => $_clearField(1802); @$pb.TagNumber(1803) - $core.int get dctcpInfoAlpha => $_getIZ(145); + $core.int get dctcpInfoAlpha => $_getIZ(146); @$pb.TagNumber(1803) - set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(145, value); + set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(146, value); @$pb.TagNumber(1803) - $core.bool hasDctcpInfoAlpha() => $_has(145); + $core.bool hasDctcpInfoAlpha() => $_has(146); @$pb.TagNumber(1803) void clearDctcpInfoAlpha() => $_clearField(1803); @$pb.TagNumber(1804) - $core.int get dctcpInfoAbEcn => $_getIZ(146); + $core.int get dctcpInfoAbEcn => $_getIZ(147); @$pb.TagNumber(1804) - set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(146, value); + set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(147, value); @$pb.TagNumber(1804) - $core.bool hasDctcpInfoAbEcn() => $_has(146); + $core.bool hasDctcpInfoAbEcn() => $_has(147); @$pb.TagNumber(1804) void clearDctcpInfoAbEcn() => $_clearField(1804); @$pb.TagNumber(1805) - $core.int get dctcpInfoAbTot => $_getIZ(147); + $core.int get dctcpInfoAbTot => $_getIZ(148); @$pb.TagNumber(1805) - set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(147, value); + set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(148, value); @$pb.TagNumber(1805) - $core.bool hasDctcpInfoAbTot() => $_has(147); + $core.bool hasDctcpInfoAbTot() => $_has(148); @$pb.TagNumber(1805) void clearDctcpInfoAbTot() => $_clearField(1805); @$pb.TagNumber(1901) - $core.int get bbrInfoBwLo => $_getIZ(148); + $core.int get bbrInfoBwLo => $_getIZ(149); @$pb.TagNumber(1901) - set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(148, value); + set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(149, value); @$pb.TagNumber(1901) - $core.bool hasBbrInfoBwLo() => $_has(148); + $core.bool hasBbrInfoBwLo() => $_has(149); @$pb.TagNumber(1901) void clearBbrInfoBwLo() => $_clearField(1901); @$pb.TagNumber(1902) - $core.int get bbrInfoBwHi => $_getIZ(149); + $core.int get bbrInfoBwHi => $_getIZ(150); @$pb.TagNumber(1902) - set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(149, value); + set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(150, value); @$pb.TagNumber(1902) - $core.bool hasBbrInfoBwHi() => $_has(149); + $core.bool hasBbrInfoBwHi() => $_has(150); @$pb.TagNumber(1902) void clearBbrInfoBwHi() => $_clearField(1902); @$pb.TagNumber(1903) - $core.int get bbrInfoMinRtt => $_getIZ(150); + $core.int get bbrInfoMinRtt => $_getIZ(151); @$pb.TagNumber(1903) - set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(150, value); + set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(151, value); @$pb.TagNumber(1903) - $core.bool hasBbrInfoMinRtt() => $_has(150); + $core.bool hasBbrInfoMinRtt() => $_has(151); @$pb.TagNumber(1903) void clearBbrInfoMinRtt() => $_clearField(1903); @$pb.TagNumber(1904) - $core.int get bbrInfoPacingGain => $_getIZ(151); + $core.int get bbrInfoPacingGain => $_getIZ(152); @$pb.TagNumber(1904) - set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(151, value); + set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(152, value); @$pb.TagNumber(1904) - $core.bool hasBbrInfoPacingGain() => $_has(151); + $core.bool hasBbrInfoPacingGain() => $_has(152); @$pb.TagNumber(1904) void clearBbrInfoPacingGain() => $_clearField(1904); @$pb.TagNumber(1905) - $core.int get bbrInfoCwndGain => $_getIZ(152); + $core.int get bbrInfoCwndGain => $_getIZ(153); @$pb.TagNumber(1905) - set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(152, value); + set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(153, value); @$pb.TagNumber(1905) - $core.bool hasBbrInfoCwndGain() => $_has(152); + $core.bool hasBbrInfoCwndGain() => $_has(153); @$pb.TagNumber(1905) void clearBbrInfoCwndGain() => $_clearField(1905); @$pb.TagNumber(2001) - $core.int get classId => $_getIZ(153); + $core.int get classId => $_getIZ(154); @$pb.TagNumber(2001) - set classId($core.int value) => $_setUnsignedInt32(153, value); + set classId($core.int value) => $_setUnsignedInt32(154, value); @$pb.TagNumber(2001) - $core.bool hasClassId() => $_has(153); + $core.bool hasClassId() => $_has(154); @$pb.TagNumber(2001) void clearClassId() => $_clearField(2001); @$pb.TagNumber(2002) - $core.int get sockOpt => $_getIZ(154); + $core.int get sockOpt => $_getIZ(155); @$pb.TagNumber(2002) - set sockOpt($core.int value) => $_setUnsignedInt32(154, value); + set sockOpt($core.int value) => $_setUnsignedInt32(155, value); @$pb.TagNumber(2002) - $core.bool hasSockOpt() => $_has(154); + $core.bool hasSockOpt() => $_has(155); @$pb.TagNumber(2002) void clearSockOpt() => $_clearField(2002); @$pb.TagNumber(2103) - $fixnum.Int64 get cGroup => $_getI64(155); + $fixnum.Int64 get cGroup => $_getI64(156); @$pb.TagNumber(2103) - set cGroup($fixnum.Int64 value) => $_setInt64(155, value); + set cGroup($fixnum.Int64 value) => $_setInt64(156, value); @$pb.TagNumber(2103) - $core.bool hasCGroup() => $_has(155); + $core.bool hasCGroup() => $_has(156); @$pb.TagNumber(2103) void clearCGroup() => $_clearField(2103); } diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart index 6c38ba6..3554d0c 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart @@ -351,6 +351,13 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'inetDiagMsgInode' }, + { + '1': 'inet_diag_msg_socket_dest_network_owner', + '3': 1018, + '4': 1, + '5': 9, + '10': 'inetDiagMsgSocketDestNetworkOwner' + }, {'1': 'mem_info_rmem', '3': 1101, '4': 1, '5': 13, '10': 'memInfoRmem'}, {'1': 'mem_info_wmem', '3': 1102, '4': 1, '5': 13, '10': 'memInfoWmem'}, {'1': 'mem_info_fmem', '3': 1103, '4': 1, '5': 13, '10': 'memInfoFmem'}, @@ -965,93 +972,95 @@ final $typed_data.Uint8List xtcpFlatRecordDescriptor = $convert.base64Decode( 'JxdWV1ZRj2ByABKA1SEWluZXREaWFnTXNnUnF1ZXVlEjAKFGluZXRfZGlhZ19tc2dfd3F1ZXVl' 'GPcHIAEoDVIRaW5ldERpYWdNc2dXcXVldWUSKgoRaW5ldF9kaWFnX21zZ191aWQY+AcgASgNUg' '5pbmV0RGlhZ01zZ1VpZBIuChNpbmV0X2RpYWdfbXNnX2lub2RlGPkHIAEoDVIQaW5ldERpYWdN' - 'c2dJbm9kZRIjCg1tZW1faW5mb19ybWVtGM0IIAEoDVILbWVtSW5mb1JtZW0SIwoNbWVtX2luZm' - '9fd21lbRjOCCABKA1SC21lbUluZm9XbWVtEiMKDW1lbV9pbmZvX2ZtZW0YzwggASgNUgttZW1J' - 'bmZvRm1lbRIjCg1tZW1faW5mb190bWVtGNAIIAEoDVILbWVtSW5mb1RtZW0SJQoOdGNwX2luZm' - '9fc3RhdGUYsQkgASgNUgx0Y3BJbmZvU3RhdGUSKgoRdGNwX2luZm9fY2Ffc3RhdGUYsgkgASgN' - 'Ug50Y3BJbmZvQ2FTdGF0ZRIxChR0Y3BfaW5mb19yZXRyYW5zbWl0cxizCSABKA1SEnRjcEluZm' - '9SZXRyYW5zbWl0cxInCg90Y3BfaW5mb19wcm9iZXMYtAkgASgNUg10Y3BJbmZvUHJvYmVzEikK' - 'EHRjcF9pbmZvX2JhY2tvZmYYtQkgASgNUg50Y3BJbmZvQmFja29mZhIpChB0Y3BfaW5mb19vcH' - 'Rpb25zGLYJIAEoDVIOdGNwSW5mb09wdGlvbnMSLgoTdGNwX2luZm9fc2VuZF9zY2FsZRi3CSAB' - 'KA1SEHRjcEluZm9TZW5kU2NhbGUSLAoSdGNwX2luZm9fcmN2X3NjYWxlGLgJIAEoDVIPdGNwSW' - '5mb1JjdlNjYWxlEkoKInRjcF9pbmZvX2RlbGl2ZXJ5X3JhdGVfYXBwX2xpbWl0ZWQYuQkgASgN' - 'Uh10Y3BJbmZvRGVsaXZlcnlSYXRlQXBwTGltaXRlZBJGCiB0Y3BfaW5mb19mYXN0X29wZW5fY2' - 'xpZW50X2ZhaWxlZBi6CSABKA1SG3RjcEluZm9GYXN0T3BlbkNsaWVudEZhaWxlZBIhCgx0Y3Bf' - 'aW5mb19ydG8YvwkgASgNUgp0Y3BJbmZvUnRvEiEKDHRjcF9pbmZvX2F0bxjACSABKA1SCnRjcE' - 'luZm9BdG8SKAoQdGNwX2luZm9fc25kX21zcxjBCSABKA1SDXRjcEluZm9TbmRNc3MSKAoQdGNw' - 'X2luZm9fcmN2X21zcxjCCSABKA1SDXRjcEluZm9SY3ZNc3MSKQoQdGNwX2luZm9fdW5hY2tlZB' - 'jDCSABKA1SDnRjcEluZm9VbmFja2VkEicKD3RjcF9pbmZvX3NhY2tlZBjECSABKA1SDXRjcElu' - 'Zm9TYWNrZWQSIwoNdGNwX2luZm9fbG9zdBjFCSABKA1SC3RjcEluZm9Mb3N0EikKEHRjcF9pbm' - 'ZvX3JldHJhbnMYxgkgASgNUg50Y3BJbmZvUmV0cmFucxIpChB0Y3BfaW5mb19mYWNrZXRzGMcJ' - 'IAEoDVIOdGNwSW5mb0ZhY2tldHMSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3NlbnQYyAkgASgNUh' - 'N0Y3BJbmZvTGFzdERhdGFTZW50EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3NlbnQYyQkgASgNUhJ0' - 'Y3BJbmZvTGFzdEFja1NlbnQSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3JlY3YYygkgASgNUhN0Y3' - 'BJbmZvTGFzdERhdGFSZWN2EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3JlY3YYywkgASgNUhJ0Y3BJ' - 'bmZvTGFzdEFja1JlY3YSIwoNdGNwX2luZm9fcG10dRjMCSABKA1SC3RjcEluZm9QbXR1EjIKFX' - 'RjcF9pbmZvX3Jjdl9zc3RocmVzaBjNCSABKA1SEnRjcEluZm9SY3ZTc3RocmVzaBIhCgx0Y3Bf' - 'aW5mb19ydHQYzgkgASgNUgp0Y3BJbmZvUnR0EigKEHRjcF9pbmZvX3J0dF92YXIYzwkgASgNUg' - '10Y3BJbmZvUnR0VmFyEjIKFXRjcF9pbmZvX3NuZF9zc3RocmVzaBjQCSABKA1SEnRjcEluZm9T' - 'bmRTc3RocmVzaBIqChF0Y3BfaW5mb19zbmRfY3duZBjRCSABKA1SDnRjcEluZm9TbmRDd25kEi' - 'gKEHRjcF9pbmZvX2Fkdl9tc3MY0gkgASgNUg10Y3BJbmZvQWR2TXNzEi8KE3RjcF9pbmZvX3Jl' - 'b3JkZXJpbmcY0wkgASgNUhF0Y3BJbmZvUmVvcmRlcmluZxIoChB0Y3BfaW5mb19yY3ZfcnR0GN' - 'QJIAEoDVINdGNwSW5mb1JjdlJ0dBIsChJ0Y3BfaW5mb19yY3Zfc3BhY2UY1QkgASgNUg90Y3BJ' - 'bmZvUmN2U3BhY2USNAoWdGNwX2luZm9fdG90YWxfcmV0cmFucxjWCSABKA1SE3RjcEluZm9Ub3' - 'RhbFJldHJhbnMSMAoUdGNwX2luZm9fcGFjaW5nX3JhdGUY1wkgASgEUhF0Y3BJbmZvUGFjaW5n' - 'UmF0ZRI3Chh0Y3BfaW5mb19tYXhfcGFjaW5nX3JhdGUY2AkgASgEUhR0Y3BJbmZvTWF4UGFjaW' - '5nUmF0ZRIwChR0Y3BfaW5mb19ieXRlc19hY2tlZBjZCSABKARSEXRjcEluZm9CeXRlc0Fja2Vk' - 'EjYKF3RjcF9pbmZvX2J5dGVzX3JlY2VpdmVkGNoJIAEoBFIUdGNwSW5mb0J5dGVzUmVjZWl2ZW' - 'QSKgoRdGNwX2luZm9fc2Vnc19vdXQY2wkgASgNUg50Y3BJbmZvU2Vnc091dBIoChB0Y3BfaW5m' - 'b19zZWdzX2luGNwJIAEoDVINdGNwSW5mb1NlZ3NJbhI1Chd0Y3BfaW5mb19ub3Rfc2VudF9ieX' - 'RlcxjdCSABKA1SE3RjcEluZm9Ob3RTZW50Qnl0ZXMSKAoQdGNwX2luZm9fbWluX3J0dBjeCSAB' - 'KA1SDXRjcEluZm9NaW5SdHQSMQoVdGNwX2luZm9fZGF0YV9zZWdzX2luGN8JIAEoDVIRdGNwSW' - '5mb0RhdGFTZWdzSW4SMwoWdGNwX2luZm9fZGF0YV9zZWdzX291dBjgCSABKA1SEnRjcEluZm9E' - 'YXRhU2Vnc091dBI0ChZ0Y3BfaW5mb19kZWxpdmVyeV9yYXRlGOEJIAEoBFITdGNwSW5mb0RlbG' - 'l2ZXJ5UmF0ZRIsChJ0Y3BfaW5mb19idXN5X3RpbWUY4gkgASgEUg90Y3BJbmZvQnVzeVRpbWUS' - 'MgoVdGNwX2luZm9fcnduZF9saW1pdGVkGOMJIAEoBFISdGNwSW5mb1J3bmRMaW1pdGVkEjYKF3' - 'RjcF9pbmZvX3NuZGJ1Zl9saW1pdGVkGOQJIAEoBFIUdGNwSW5mb1NuZGJ1ZkxpbWl0ZWQSLQoS' - 'dGNwX2luZm9fZGVsaXZlcmVkGOUJIAEoDVIQdGNwSW5mb0RlbGl2ZXJlZBIyChV0Y3BfaW5mb1' - '9kZWxpdmVyZWRfY2UY5gkgASgNUhJ0Y3BJbmZvRGVsaXZlcmVkQ2USLgoTdGNwX2luZm9fYnl0' - 'ZXNfc2VudBjnCSABKARSEHRjcEluZm9CeXRlc1NlbnQSNAoWdGNwX2luZm9fYnl0ZXNfcmV0cm' - 'FucxjoCSABKARSE3RjcEluZm9CeXRlc1JldHJhbnMSLgoTdGNwX2luZm9fZHNhY2tfZHVwcxjp' - 'CSABKA1SEHRjcEluZm9Ec2Fja0R1cHMSLgoTdGNwX2luZm9fcmVvcmRfc2VlbhjqCSABKA1SEH' - 'RjcEluZm9SZW9yZFNlZW4SMAoUdGNwX2luZm9fcmN2X29vb3BhY2sY6wkgASgNUhF0Y3BJbmZv' - 'UmN2T29vcGFjaxIoChB0Y3BfaW5mb19zbmRfd25kGOwJIAEoDVINdGNwSW5mb1NuZFduZBIoCh' - 'B0Y3BfaW5mb19yY3Zfd25kGO0JIAEoDVINdGNwSW5mb1JjdlduZBInCg90Y3BfaW5mb19yZWhh' - 'c2gY7gkgASgNUg10Y3BJbmZvUmVoYXNoEiwKEnRjcF9pbmZvX3RvdGFsX3J0bxjvCSABKA1SD3' - 'RjcEluZm9Ub3RhbFJ0bxJBCh10Y3BfaW5mb190b3RhbF9ydG9fcmVjb3ZlcmllcxjwCSABKA1S' - 'GXRjcEluZm9Ub3RhbFJ0b1JlY292ZXJpZXMSNQoXdGNwX2luZm9fdG90YWxfcnRvX3RpbWUY8Q' - 'kgASgNUhN0Y3BJbmZvVG90YWxSdG9UaW1lEj8KG2Nvbmdlc3Rpb25fYWxnb3JpdGhtX3N0cmlu' - 'ZxiUCiABKAlSGWNvbmdlc3Rpb25BbGdvcml0aG1TdHJpbmcSdAoZY29uZ2VzdGlvbl9hbGdvcm' - 'l0aG1fZW51bRiVCiABKA4yNy54dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbGF0UmVjb3JkLkNv' - 'bmdlc3Rpb25BbGdvcml0aG1SF2Nvbmdlc3Rpb25BbGdvcml0aG1FbnVtEicKD3R5cGVfb2Zfc2' - 'VydmljZRj5CiABKA1SDXR5cGVPZlNlcnZpY2USJAoNdHJhZmZpY19jbGFzcxj6CiABKA1SDHRy' - 'YWZmaWNDbGFzcxIzChZza19tZW1faW5mb19ybWVtX2FsbG9jGN0LIAEoDVISc2tNZW1JbmZvUm' - '1lbUFsbG9jEi0KE3NrX21lbV9pbmZvX3Jjdl9idWYY3gsgASgNUg9za01lbUluZm9SY3ZCdWYS' - 'MwoWc2tfbWVtX2luZm9fd21lbV9hbGxvYxjfCyABKA1SEnNrTWVtSW5mb1dtZW1BbGxvYxItCh' - 'Nza19tZW1faW5mb19zbmRfYnVmGOALIAEoDVIPc2tNZW1JbmZvU25kQnVmEjEKFXNrX21lbV9p' - 'bmZvX2Z3ZF9hbGxvYxjhCyABKA1SEXNrTWVtSW5mb0Z3ZEFsbG9jEjUKF3NrX21lbV9pbmZvX3' - 'dtZW1fcXVldWVkGOILIAEoDVITc2tNZW1JbmZvV21lbVF1ZXVlZBIsChJza19tZW1faW5mb19v' - 'cHRtZW0Y4wsgASgNUg9za01lbUluZm9PcHRtZW0SLgoTc2tfbWVtX2luZm9fYmFja2xvZxjkCy' - 'ABKA1SEHNrTWVtSW5mb0JhY2tsb2cSKgoRc2tfbWVtX2luZm9fZHJvcHMY5QsgASgNUg5za01l' - 'bUluZm9Ecm9wcxImCg5zaHV0ZG93bl9zdGF0ZRjADCABKA1SDXNodXRkb3duU3RhdGUSLQoSdm' - 'VnYXNfaW5mb19lbmFibGVkGKUNIAEoDVIQdmVnYXNJbmZvRW5hYmxlZBIsChJ2ZWdhc19pbmZv' - 'X3J0dF9jbnQYpg0gASgNUg92ZWdhc0luZm9SdHRDbnQSJQoOdmVnYXNfaW5mb19ydHQYpw0gAS' - 'gNUgx2ZWdhc0luZm9SdHQSLAoSdmVnYXNfaW5mb19taW5fcnR0GKgNIAEoDVIPdmVnYXNJbmZv' - 'TWluUnR0Ei0KEmRjdGNwX2luZm9fZW5hYmxlZBiJDiABKA1SEGRjdGNwSW5mb0VuYWJsZWQSLg' - 'oTZGN0Y3BfaW5mb19jZV9zdGF0ZRiKDiABKA1SEGRjdGNwSW5mb0NlU3RhdGUSKQoQZGN0Y3Bf' - 'aW5mb19hbHBoYRiLDiABKA1SDmRjdGNwSW5mb0FscGhhEioKEWRjdGNwX2luZm9fYWJfZWNuGI' - 'wOIAEoDVIOZGN0Y3BJbmZvQWJFY24SKgoRZGN0Y3BfaW5mb19hYl90b3QYjQ4gASgNUg5kY3Rj' - 'cEluZm9BYlRvdBIkCg5iYnJfaW5mb19id19sbxjtDiABKA1SC2JickluZm9Cd0xvEiQKDmJicl' - '9pbmZvX2J3X2hpGO4OIAEoDVILYmJySW5mb0J3SGkSKAoQYmJyX2luZm9fbWluX3J0dBjvDiAB' - 'KA1SDWJickluZm9NaW5SdHQSMAoUYmJyX2luZm9fcGFjaW5nX2dhaW4Y8A4gASgNUhFiYnJJbm' - 'ZvUGFjaW5nR2FpbhIsChJiYnJfaW5mb19jd25kX2dhaW4Y8Q4gASgNUg9iYnJJbmZvQ3duZEdh' - 'aW4SGgoIY2xhc3NfaWQY0Q8gASgNUgdjbGFzc0lkEhoKCHNvY2tfb3B0GNIPIAEoDVIHc29ja0' - '9wdBIYCgdjX2dyb3VwGLcQIAEoBFIGY0dyb3VwIpkCChNDb25nZXN0aW9uQWxnb3JpdGhtEiQK' - 'IENPTkdFU1RJT05fQUxHT1JJVEhNX1VOU1BFQ0lGSUVEEAASHgoaQ09OR0VTVElPTl9BTEdPUk' - 'lUSE1fQ1VCSUMQARIeChpDT05HRVNUSU9OX0FMR09SSVRITV9EQ1RDUBACEh4KGkNPTkdFU1RJ' - 'T05fQUxHT1JJVEhNX1ZFR0FTEAMSHwobQ09OR0VTVElPTl9BTEdPUklUSE1fUFJBR1VFEAQSHQ' - 'oZQ09OR0VTVElPTl9BTEdPUklUSE1fQkJSMRAFEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JC' - 'UjIQBhIdChlDT05HRVNUSU9OX0FMR09SSVRITV9CQlIzEAc='); + 'c2dJbm9kZRJTCidpbmV0X2RpYWdfbXNnX3NvY2tldF9kZXN0X25ldHdvcmtfb3duZXIY+gcgAS' + 'gJUiFpbmV0RGlhZ01zZ1NvY2tldERlc3ROZXR3b3JrT3duZXISIwoNbWVtX2luZm9fcm1lbRjN' + 'CCABKA1SC21lbUluZm9SbWVtEiMKDW1lbV9pbmZvX3dtZW0YzgggASgNUgttZW1JbmZvV21lbR' + 'IjCg1tZW1faW5mb19mbWVtGM8IIAEoDVILbWVtSW5mb0ZtZW0SIwoNbWVtX2luZm9fdG1lbRjQ' + 'CCABKA1SC21lbUluZm9UbWVtEiUKDnRjcF9pbmZvX3N0YXRlGLEJIAEoDVIMdGNwSW5mb1N0YX' + 'RlEioKEXRjcF9pbmZvX2NhX3N0YXRlGLIJIAEoDVIOdGNwSW5mb0NhU3RhdGUSMQoUdGNwX2lu' + 'Zm9fcmV0cmFuc21pdHMYswkgASgNUhJ0Y3BJbmZvUmV0cmFuc21pdHMSJwoPdGNwX2luZm9fcH' + 'JvYmVzGLQJIAEoDVINdGNwSW5mb1Byb2JlcxIpChB0Y3BfaW5mb19iYWNrb2ZmGLUJIAEoDVIO' + 'dGNwSW5mb0JhY2tvZmYSKQoQdGNwX2luZm9fb3B0aW9ucxi2CSABKA1SDnRjcEluZm9PcHRpb2' + '5zEi4KE3RjcF9pbmZvX3NlbmRfc2NhbGUYtwkgASgNUhB0Y3BJbmZvU2VuZFNjYWxlEiwKEnRj' + 'cF9pbmZvX3Jjdl9zY2FsZRi4CSABKA1SD3RjcEluZm9SY3ZTY2FsZRJKCiJ0Y3BfaW5mb19kZW' + 'xpdmVyeV9yYXRlX2FwcF9saW1pdGVkGLkJIAEoDVIddGNwSW5mb0RlbGl2ZXJ5UmF0ZUFwcExp' + 'bWl0ZWQSRgogdGNwX2luZm9fZmFzdF9vcGVuX2NsaWVudF9mYWlsZWQYugkgASgNUht0Y3BJbm' + 'ZvRmFzdE9wZW5DbGllbnRGYWlsZWQSIQoMdGNwX2luZm9fcnRvGL8JIAEoDVIKdGNwSW5mb1J0' + 'bxIhCgx0Y3BfaW5mb19hdG8YwAkgASgNUgp0Y3BJbmZvQXRvEigKEHRjcF9pbmZvX3NuZF9tc3' + 'MYwQkgASgNUg10Y3BJbmZvU25kTXNzEigKEHRjcF9pbmZvX3Jjdl9tc3MYwgkgASgNUg10Y3BJ' + 'bmZvUmN2TXNzEikKEHRjcF9pbmZvX3VuYWNrZWQYwwkgASgNUg50Y3BJbmZvVW5hY2tlZBInCg' + '90Y3BfaW5mb19zYWNrZWQYxAkgASgNUg10Y3BJbmZvU2Fja2VkEiMKDXRjcF9pbmZvX2xvc3QY' + 'xQkgASgNUgt0Y3BJbmZvTG9zdBIpChB0Y3BfaW5mb19yZXRyYW5zGMYJIAEoDVIOdGNwSW5mb1' + 'JldHJhbnMSKQoQdGNwX2luZm9fZmFja2V0cxjHCSABKA1SDnRjcEluZm9GYWNrZXRzEjUKF3Rj' + 'cF9pbmZvX2xhc3RfZGF0YV9zZW50GMgJIAEoDVITdGNwSW5mb0xhc3REYXRhU2VudBIzChZ0Y3' + 'BfaW5mb19sYXN0X2Fja19zZW50GMkJIAEoDVISdGNwSW5mb0xhc3RBY2tTZW50EjUKF3RjcF9p' + 'bmZvX2xhc3RfZGF0YV9yZWN2GMoJIAEoDVITdGNwSW5mb0xhc3REYXRhUmVjdhIzChZ0Y3BfaW' + '5mb19sYXN0X2Fja19yZWN2GMsJIAEoDVISdGNwSW5mb0xhc3RBY2tSZWN2EiMKDXRjcF9pbmZv' + 'X3BtdHUYzAkgASgNUgt0Y3BJbmZvUG10dRIyChV0Y3BfaW5mb19yY3Zfc3N0aHJlc2gYzQkgAS' + 'gNUhJ0Y3BJbmZvUmN2U3N0aHJlc2gSIQoMdGNwX2luZm9fcnR0GM4JIAEoDVIKdGNwSW5mb1J0' + 'dBIoChB0Y3BfaW5mb19ydHRfdmFyGM8JIAEoDVINdGNwSW5mb1J0dFZhchIyChV0Y3BfaW5mb1' + '9zbmRfc3N0aHJlc2gY0AkgASgNUhJ0Y3BJbmZvU25kU3N0aHJlc2gSKgoRdGNwX2luZm9fc25k' + 'X2N3bmQY0QkgASgNUg50Y3BJbmZvU25kQ3duZBIoChB0Y3BfaW5mb19hZHZfbXNzGNIJIAEoDV' + 'INdGNwSW5mb0Fkdk1zcxIvChN0Y3BfaW5mb19yZW9yZGVyaW5nGNMJIAEoDVIRdGNwSW5mb1Jl' + 'b3JkZXJpbmcSKAoQdGNwX2luZm9fcmN2X3J0dBjUCSABKA1SDXRjcEluZm9SY3ZSdHQSLAoSdG' + 'NwX2luZm9fcmN2X3NwYWNlGNUJIAEoDVIPdGNwSW5mb1JjdlNwYWNlEjQKFnRjcF9pbmZvX3Rv' + 'dGFsX3JldHJhbnMY1gkgASgNUhN0Y3BJbmZvVG90YWxSZXRyYW5zEjAKFHRjcF9pbmZvX3BhY2' + 'luZ19yYXRlGNcJIAEoBFIRdGNwSW5mb1BhY2luZ1JhdGUSNwoYdGNwX2luZm9fbWF4X3BhY2lu' + 'Z19yYXRlGNgJIAEoBFIUdGNwSW5mb01heFBhY2luZ1JhdGUSMAoUdGNwX2luZm9fYnl0ZXNfYW' + 'NrZWQY2QkgASgEUhF0Y3BJbmZvQnl0ZXNBY2tlZBI2Chd0Y3BfaW5mb19ieXRlc19yZWNlaXZl' + 'ZBjaCSABKARSFHRjcEluZm9CeXRlc1JlY2VpdmVkEioKEXRjcF9pbmZvX3NlZ3Nfb3V0GNsJIA' + 'EoDVIOdGNwSW5mb1NlZ3NPdXQSKAoQdGNwX2luZm9fc2Vnc19pbhjcCSABKA1SDXRjcEluZm9T' + 'ZWdzSW4SNQoXdGNwX2luZm9fbm90X3NlbnRfYnl0ZXMY3QkgASgNUhN0Y3BJbmZvTm90U2VudE' + 'J5dGVzEigKEHRjcF9pbmZvX21pbl9ydHQY3gkgASgNUg10Y3BJbmZvTWluUnR0EjEKFXRjcF9p' + 'bmZvX2RhdGFfc2Vnc19pbhjfCSABKA1SEXRjcEluZm9EYXRhU2Vnc0luEjMKFnRjcF9pbmZvX2' + 'RhdGFfc2Vnc19vdXQY4AkgASgNUhJ0Y3BJbmZvRGF0YVNlZ3NPdXQSNAoWdGNwX2luZm9fZGVs' + 'aXZlcnlfcmF0ZRjhCSABKARSE3RjcEluZm9EZWxpdmVyeVJhdGUSLAoSdGNwX2luZm9fYnVzeV' + '90aW1lGOIJIAEoBFIPdGNwSW5mb0J1c3lUaW1lEjIKFXRjcF9pbmZvX3J3bmRfbGltaXRlZBjj' + 'CSABKARSEnRjcEluZm9Sd25kTGltaXRlZBI2Chd0Y3BfaW5mb19zbmRidWZfbGltaXRlZBjkCS' + 'ABKARSFHRjcEluZm9TbmRidWZMaW1pdGVkEi0KEnRjcF9pbmZvX2RlbGl2ZXJlZBjlCSABKA1S' + 'EHRjcEluZm9EZWxpdmVyZWQSMgoVdGNwX2luZm9fZGVsaXZlcmVkX2NlGOYJIAEoDVISdGNwSW' + '5mb0RlbGl2ZXJlZENlEi4KE3RjcF9pbmZvX2J5dGVzX3NlbnQY5wkgASgEUhB0Y3BJbmZvQnl0' + 'ZXNTZW50EjQKFnRjcF9pbmZvX2J5dGVzX3JldHJhbnMY6AkgASgEUhN0Y3BJbmZvQnl0ZXNSZX' + 'RyYW5zEi4KE3RjcF9pbmZvX2RzYWNrX2R1cHMY6QkgASgNUhB0Y3BJbmZvRHNhY2tEdXBzEi4K' + 'E3RjcF9pbmZvX3Jlb3JkX3NlZW4Y6gkgASgNUhB0Y3BJbmZvUmVvcmRTZWVuEjAKFHRjcF9pbm' + 'ZvX3Jjdl9vb29wYWNrGOsJIAEoDVIRdGNwSW5mb1Jjdk9vb3BhY2sSKAoQdGNwX2luZm9fc25k' + 'X3duZBjsCSABKA1SDXRjcEluZm9TbmRXbmQSKAoQdGNwX2luZm9fcmN2X3duZBjtCSABKA1SDX' + 'RjcEluZm9SY3ZXbmQSJwoPdGNwX2luZm9fcmVoYXNoGO4JIAEoDVINdGNwSW5mb1JlaGFzaBIs' + 'ChJ0Y3BfaW5mb190b3RhbF9ydG8Y7wkgASgNUg90Y3BJbmZvVG90YWxSdG8SQQoddGNwX2luZm' + '9fdG90YWxfcnRvX3JlY292ZXJpZXMY8AkgASgNUhl0Y3BJbmZvVG90YWxSdG9SZWNvdmVyaWVz' + 'EjUKF3RjcF9pbmZvX3RvdGFsX3J0b190aW1lGPEJIAEoDVITdGNwSW5mb1RvdGFsUnRvVGltZR' + 'I/Chtjb25nZXN0aW9uX2FsZ29yaXRobV9zdHJpbmcYlAogASgJUhljb25nZXN0aW9uQWxnb3Jp' + 'dGhtU3RyaW5nEnQKGWNvbmdlc3Rpb25fYWxnb3JpdGhtX2VudW0YlQogASgOMjcueHRjcF9mbG' + 'F0X3JlY29yZC52MS5YdGNwRmxhdFJlY29yZC5Db25nZXN0aW9uQWxnb3JpdGhtUhdjb25nZXN0' + 'aW9uQWxnb3JpdGhtRW51bRInCg90eXBlX29mX3NlcnZpY2UY+QogASgNUg10eXBlT2ZTZXJ2aW' + 'NlEiQKDXRyYWZmaWNfY2xhc3MY+gogASgNUgx0cmFmZmljQ2xhc3MSMwoWc2tfbWVtX2luZm9f' + 'cm1lbV9hbGxvYxjdCyABKA1SEnNrTWVtSW5mb1JtZW1BbGxvYxItChNza19tZW1faW5mb19yY3' + 'ZfYnVmGN4LIAEoDVIPc2tNZW1JbmZvUmN2QnVmEjMKFnNrX21lbV9pbmZvX3dtZW1fYWxsb2MY' + '3wsgASgNUhJza01lbUluZm9XbWVtQWxsb2MSLQoTc2tfbWVtX2luZm9fc25kX2J1ZhjgCyABKA' + '1SD3NrTWVtSW5mb1NuZEJ1ZhIxChVza19tZW1faW5mb19md2RfYWxsb2MY4QsgASgNUhFza01l' + 'bUluZm9Gd2RBbGxvYxI1Chdza19tZW1faW5mb193bWVtX3F1ZXVlZBjiCyABKA1SE3NrTWVtSW' + '5mb1dtZW1RdWV1ZWQSLAoSc2tfbWVtX2luZm9fb3B0bWVtGOMLIAEoDVIPc2tNZW1JbmZvT3B0' + 'bWVtEi4KE3NrX21lbV9pbmZvX2JhY2tsb2cY5AsgASgNUhBza01lbUluZm9CYWNrbG9nEioKEX' + 'NrX21lbV9pbmZvX2Ryb3BzGOULIAEoDVIOc2tNZW1JbmZvRHJvcHMSJgoOc2h1dGRvd25fc3Rh' + 'dGUYwAwgASgNUg1zaHV0ZG93blN0YXRlEi0KEnZlZ2FzX2luZm9fZW5hYmxlZBilDSABKA1SEH' + 'ZlZ2FzSW5mb0VuYWJsZWQSLAoSdmVnYXNfaW5mb19ydHRfY250GKYNIAEoDVIPdmVnYXNJbmZv' + 'UnR0Q250EiUKDnZlZ2FzX2luZm9fcnR0GKcNIAEoDVIMdmVnYXNJbmZvUnR0EiwKEnZlZ2FzX2' + 'luZm9fbWluX3J0dBioDSABKA1SD3ZlZ2FzSW5mb01pblJ0dBItChJkY3RjcF9pbmZvX2VuYWJs' + 'ZWQYiQ4gASgNUhBkY3RjcEluZm9FbmFibGVkEi4KE2RjdGNwX2luZm9fY2Vfc3RhdGUYig4gAS' + 'gNUhBkY3RjcEluZm9DZVN0YXRlEikKEGRjdGNwX2luZm9fYWxwaGEYiw4gASgNUg5kY3RjcElu' + 'Zm9BbHBoYRIqChFkY3RjcF9pbmZvX2FiX2VjbhiMDiABKA1SDmRjdGNwSW5mb0FiRWNuEioKEW' + 'RjdGNwX2luZm9fYWJfdG90GI0OIAEoDVIOZGN0Y3BJbmZvQWJUb3QSJAoOYmJyX2luZm9fYndf' + 'bG8Y7Q4gASgNUgtiYnJJbmZvQndMbxIkCg5iYnJfaW5mb19id19oaRjuDiABKA1SC2JickluZm' + '9Cd0hpEigKEGJicl9pbmZvX21pbl9ydHQY7w4gASgNUg1iYnJJbmZvTWluUnR0EjAKFGJicl9p' + 'bmZvX3BhY2luZ19nYWluGPAOIAEoDVIRYmJySW5mb1BhY2luZ0dhaW4SLAoSYmJyX2luZm9fY3' + 'duZF9nYWluGPEOIAEoDVIPYmJySW5mb0N3bmRHYWluEhoKCGNsYXNzX2lkGNEPIAEoDVIHY2xh' + 'c3NJZBIaCghzb2NrX29wdBjSDyABKA1SB3NvY2tPcHQSGAoHY19ncm91cBi3ECABKARSBmNHcm' + '91cCKZAgoTQ29uZ2VzdGlvbkFsZ29yaXRobRIkCiBDT05HRVNUSU9OX0FMR09SSVRITV9VTlNQ' + 'RUNJRklFRBAAEh4KGkNPTkdFU1RJT05fQUxHT1JJVEhNX0NVQklDEAESHgoaQ09OR0VTVElPTl' + '9BTEdPUklUSE1fRENUQ1AQAhIeChpDT05HRVNUSU9OX0FMR09SSVRITV9WRUdBUxADEh8KG0NP' + 'TkdFU1RJT05fQUxHT1JJVEhNX1BSQUdVRRAEEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JCUj' + 'EQBRIdChlDT05HRVNUSU9OX0FMR09SSVRITV9CQlIyEAYSHQoZQ09OR0VTVElPTl9BTEdPUklU' + 'SE1fQkJSMxAH'); @$core.Deprecated('Use flatRecordsRequestDescriptor instead') const FlatRecordsRequest$json = { diff --git a/gen/go/xtcp_config/xtcp_config.pb.go b/gen/go/xtcp_config/xtcp_config.pb.go index 6ad024b..83c5811 100644 --- a/gen/go/xtcp_config/xtcp_config.pb.go +++ b/gen/go/xtcp_config/xtcp_config.pb.go @@ -970,9 +970,21 @@ type XtcpConfig struct { UplinkInterfaces []string `protobuf:"bytes,237,rep,name=uplink_interfaces,json=uplinkInterfaces,proto3" json:"uplink_interfaces,omitempty"` // Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for // Docker/containerd namespaces. Default false. - PopulateNsid bool `protobuf:"varint,238,opt,name=populate_nsid,json=populateNsid,proto3" json:"populate_nsid,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + PopulateNsid bool `protobuf:"varint,238,opt,name=populate_nsid,json=populateNsid,proto3" json:"populate_nsid,omitempty"` + // Enrich the destination IP's ASN (field 1011) and network owner (field + // 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + // artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when + // enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, + // and leaves both columns empty. Default false. + EnrichAsnEnable bool `protobuf:"varint,239,opt,name=enrich_asn_enable,json=enrichAsnEnable,proto3" json:"enrich_asn_enable,omitempty"` + // Path to the ipfeed-collector Parquet artifact (prefix -> {asn, + // network_owner}). Default "". + AsnDbPath string `protobuf:"bytes,240,opt,name=asn_db_path,json=asnDbPath,proto3" json:"asn_db_path,omitempty"` + // How often to reload asn_db_path in the background so a refreshed artifact + // is picked up without a restart. 0 = load once at startup, never reload. + AsnRefreshInterval *durationpb.Duration `protobuf:"bytes,241,opt,name=asn_refresh_interval,json=asnRefreshInterval,proto3" json:"asn_refresh_interval,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *XtcpConfig) Reset() { @@ -1467,6 +1479,27 @@ func (x *XtcpConfig) GetPopulateNsid() bool { return false } +func (x *XtcpConfig) GetEnrichAsnEnable() bool { + if x != nil { + return x.EnrichAsnEnable + } + return false +} + +func (x *XtcpConfig) GetAsnDbPath() string { + if x != nil { + return x.AsnDbPath + } + return "" +} + +func (x *XtcpConfig) GetAsnRefreshInterval() *durationpb.Duration { + if x != nil { + return x.AsnRefreshInterval + } + return nil +} + type EnabledDeserializers struct { state protoimpl.MessageState `protogen:"open.v1"` Enabled map[string]bool `protobuf:"bytes,1,rep,name=enabled,proto3" json:"enabled,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` @@ -1555,7 +1588,7 @@ const file_xtcp_config_v1_xtcp_config_proto_rawDesc = "" + "\x1denvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1aenvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n" + "\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n" + "\x18SetEnvelopeFlushResponse\x122\n" + - "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\xf9\x1d\n" + + "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\x9f\x1f\n" + "\n" + "XtcpConfig\x12F\n" + "\x17nl_timeout_milliseconds\x18\n" + @@ -1645,7 +1678,10 @@ const file_xtcp_config_v1_xtcp_config_proto_rawDesc = "" + "\x11enrich_nic_enable\x18\xeb\x01 \x01(\bR\x0fenrichNicEnable\x12+\n" + "\fuplink_count\x18\xec\x01 \x01(\rB\a\xbaH\x04*\x02\x18\x02R\vuplinkCount\x126\n" + "\x11uplink_interfaces\x18\xed\x01 \x03(\tB\b\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n" + - "\rpopulate_nsid\x18\xee\x01 \x01(\bR\fpopulateNsid:s\xbaHp\x1an\n" + + "\rpopulate_nsid\x18\xee\x01 \x01(\bR\fpopulateNsid\x12+\n" + + "\x11enrich_asn_enable\x18\xef\x01 \x01(\bR\x0fenrichAsnEnable\x12)\n" + + "\vasn_db_path\x18\xf0\x01 \x01(\tB\b\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n" + + "\x14asn_refresh_interval\x18\xf1\x01 \x01(\v2\x19.google.protobuf.DurationR\x12asnRefreshInterval:s\xbaHp\x1an\n" + "\x0fXtcpConfig.poll\x122Poll timeout must be less than poll poll_frequency\x1a'this.poll_frequency > this.poll_timeout\"\x9f\x01\n" + "\x14EnabledDeserializers\x12K\n" + "\aenabled\x18\x01 \x03(\v21.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\aenabled\x1a:\n" + @@ -1714,26 +1750,27 @@ var file_xtcp_config_v1_xtcp_config_proto_depIdxs = []int32{ 17, // 15: xtcp_config.v1.XtcpConfig.s3_flush_interval:type_name -> google.protobuf.Duration 17, // 16: xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap:type_name -> google.protobuf.Duration 17, // 17: xtcp_config.v1.XtcpConfig.reconcile_frequency:type_name -> google.protobuf.Duration - 16, // 18: xtcp_config.v1.EnabledDeserializers.enabled:type_name -> xtcp_config.v1.EnabledDeserializers.EnabledEntry - 0, // 19: xtcp_config.v1.ConfigService.Get:input_type -> xtcp_config.v1.GetRequest - 2, // 20: xtcp_config.v1.ConfigService.Set:input_type -> xtcp_config.v1.SetRequest - 4, // 21: xtcp_config.v1.ConfigService.SetPollFrequency:input_type -> xtcp_config.v1.SetPollFrequencyRequest - 6, // 22: xtcp_config.v1.ConfigService.TriggerPoll:input_type -> xtcp_config.v1.TriggerPollRequest - 8, // 23: xtcp_config.v1.ConfigService.TriggerPollBurst:input_type -> xtcp_config.v1.TriggerPollBurstRequest - 10, // 24: xtcp_config.v1.ConfigService.SetS3Upload:input_type -> xtcp_config.v1.SetS3UploadRequest - 12, // 25: xtcp_config.v1.ConfigService.SetEnvelopeFlush:input_type -> xtcp_config.v1.SetEnvelopeFlushRequest - 1, // 26: xtcp_config.v1.ConfigService.Get:output_type -> xtcp_config.v1.GetResponse - 3, // 27: xtcp_config.v1.ConfigService.Set:output_type -> xtcp_config.v1.SetResponse - 5, // 28: xtcp_config.v1.ConfigService.SetPollFrequency:output_type -> xtcp_config.v1.SetPollFrequencyResponse - 7, // 29: xtcp_config.v1.ConfigService.TriggerPoll:output_type -> xtcp_config.v1.TriggerPollResponse - 9, // 30: xtcp_config.v1.ConfigService.TriggerPollBurst:output_type -> xtcp_config.v1.TriggerPollBurstResponse - 11, // 31: xtcp_config.v1.ConfigService.SetS3Upload:output_type -> xtcp_config.v1.SetS3UploadResponse - 13, // 32: xtcp_config.v1.ConfigService.SetEnvelopeFlush:output_type -> xtcp_config.v1.SetEnvelopeFlushResponse - 26, // [26:33] is the sub-list for method output_type - 19, // [19:26] is the sub-list for method input_type - 19, // [19:19] is the sub-list for extension type_name - 19, // [19:19] is the sub-list for extension extendee - 0, // [0:19] is the sub-list for field type_name + 17, // 18: xtcp_config.v1.XtcpConfig.asn_refresh_interval:type_name -> google.protobuf.Duration + 16, // 19: xtcp_config.v1.EnabledDeserializers.enabled:type_name -> xtcp_config.v1.EnabledDeserializers.EnabledEntry + 0, // 20: xtcp_config.v1.ConfigService.Get:input_type -> xtcp_config.v1.GetRequest + 2, // 21: xtcp_config.v1.ConfigService.Set:input_type -> xtcp_config.v1.SetRequest + 4, // 22: xtcp_config.v1.ConfigService.SetPollFrequency:input_type -> xtcp_config.v1.SetPollFrequencyRequest + 6, // 23: xtcp_config.v1.ConfigService.TriggerPoll:input_type -> xtcp_config.v1.TriggerPollRequest + 8, // 24: xtcp_config.v1.ConfigService.TriggerPollBurst:input_type -> xtcp_config.v1.TriggerPollBurstRequest + 10, // 25: xtcp_config.v1.ConfigService.SetS3Upload:input_type -> xtcp_config.v1.SetS3UploadRequest + 12, // 26: xtcp_config.v1.ConfigService.SetEnvelopeFlush:input_type -> xtcp_config.v1.SetEnvelopeFlushRequest + 1, // 27: xtcp_config.v1.ConfigService.Get:output_type -> xtcp_config.v1.GetResponse + 3, // 28: xtcp_config.v1.ConfigService.Set:output_type -> xtcp_config.v1.SetResponse + 5, // 29: xtcp_config.v1.ConfigService.SetPollFrequency:output_type -> xtcp_config.v1.SetPollFrequencyResponse + 7, // 30: xtcp_config.v1.ConfigService.TriggerPoll:output_type -> xtcp_config.v1.TriggerPollResponse + 9, // 31: xtcp_config.v1.ConfigService.TriggerPollBurst:output_type -> xtcp_config.v1.TriggerPollBurstResponse + 11, // 32: xtcp_config.v1.ConfigService.SetS3Upload:output_type -> xtcp_config.v1.SetS3UploadResponse + 13, // 33: xtcp_config.v1.ConfigService.SetEnvelopeFlush:output_type -> xtcp_config.v1.SetEnvelopeFlushResponse + 27, // [27:34] is the sub-list for method output_type + 20, // [20:27] is the sub-list for method input_type + 20, // [20:20] is the sub-list for extension type_name + 20, // [20:20] is the sub-list for extension extendee + 0, // [0:20] is the sub-list for field type_name } func init() { file_xtcp_config_v1_xtcp_config_proto_init() } diff --git a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go index 0252217..56ee47f 100644 --- a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go +++ b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go @@ -659,6 +659,39 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.AsnRefreshInterval != nil { + size, err := (*durationpb.Duration)(m.AsnRefreshInterval).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xf + i-- + dAtA[i] = 0x8a + } + if len(m.AsnDbPath) > 0 { + i -= len(m.AsnDbPath) + copy(dAtA[i:], m.AsnDbPath) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AsnDbPath))) + i-- + dAtA[i] = 0xf + i-- + dAtA[i] = 0x82 + } + if m.EnrichAsnEnable { + i-- + if m.EnrichAsnEnable { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0xe + i-- + dAtA[i] = 0xf8 + } if m.PopulateNsid { i-- if m.PopulateNsid { @@ -1741,6 +1774,17 @@ func (m *XtcpConfig) SizeVT() (n int) { if m.PopulateNsid { n += 3 } + if m.EnrichAsnEnable { + n += 3 + } + l = len(m.AsnDbPath) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.AsnRefreshInterval != nil { + l = (*durationpb.Duration)(m.AsnRefreshInterval).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } n += len(m.unknownFields) return n } @@ -4703,6 +4747,94 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.PopulateNsid = bool(v != 0) + case 239: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichAsnEnable", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnrichAsnEnable = bool(v != 0) + case 240: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AsnDbPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AsnDbPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 241: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AsnRefreshInterval", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AsnRefreshInterval == nil { + m.AsnRefreshInterval = &durationpb1.Duration{} + } + if err := (*durationpb.Duration)(m.AsnRefreshInterval).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go index 54bf518..dde69fd 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go @@ -265,6 +265,11 @@ type XtcpFlatRecord struct { InetDiagMsgWqueue uint32 `protobuf:"varint,1015,opt,name=inet_diag_msg_wqueue,json=inetDiagMsgWqueue,proto3" json:"inet_diag_msg_wqueue,omitempty"` InetDiagMsgUid uint32 `protobuf:"varint,1016,opt,name=inet_diag_msg_uid,json=inetDiagMsgUid,proto3" json:"inet_diag_msg_uid,omitempty"` InetDiagMsgInode uint32 `protobuf:"varint,1017,opt,name=inet_diag_msg_inode,json=inetDiagMsgInode,proto3" json:"inet_diag_msg_inode,omitempty"` + // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range + // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the + // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the + // destination IP is not in the feed set. + InetDiagMsgSocketDestNetworkOwner string `protobuf:"bytes,1018,opt,name=inet_diag_msg_socket_dest_network_owner,json=inetDiagMsgSocketDestNetworkOwner,proto3" json:"inet_diag_msg_socket_dest_network_owner,omitempty"` // DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by // default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), // so these ship as 0 on current records. The same values live in sk_mem_info: @@ -835,6 +840,13 @@ func (x *XtcpFlatRecord) GetInetDiagMsgInode() uint32 { return 0 } +func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestNetworkOwner() string { + if x != nil { + return x.InetDiagMsgSocketDestNetworkOwner + } + return "" +} + func (x *XtcpFlatRecord) GetMemInfoRmem() uint32 { if x != nil { return x.MemInfoRmem @@ -1674,7 +1686,7 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n" + "\bEnvelope\x125\n" + "\x03row\x18\n" + - " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\x8e<\n" + + " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xe3<\n" + "\x0eXtcpFlatRecord\x12%\n" + "\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n" + "\x0edaemon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n" + @@ -1737,7 +1749,8 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x14inet_diag_msg_rqueue\x18\xf6\a \x01(\rR\x11inetDiagMsgRqueue\x120\n" + "\x14inet_diag_msg_wqueue\x18\xf7\a \x01(\rR\x11inetDiagMsgWqueue\x12*\n" + "\x11inet_diag_msg_uid\x18\xf8\a \x01(\rR\x0einetDiagMsgUid\x12.\n" + - "\x13inet_diag_msg_inode\x18\xf9\a \x01(\rR\x10inetDiagMsgInode\x12#\n" + + "\x13inet_diag_msg_inode\x18\xf9\a \x01(\rR\x10inetDiagMsgInode\x12S\n" + + "'inet_diag_msg_socket_dest_network_owner\x18\xfa\a \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12#\n" + "\rmem_info_rmem\x18\xcd\b \x01(\rR\vmemInfoRmem\x12#\n" + "\rmem_info_wmem\x18\xce\b \x01(\rR\vmemInfoWmem\x12#\n" + "\rmem_info_fmem\x18\xcf\b \x01(\rR\vmemInfoFmem\x12#\n" + diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go index 079a6c0..69a9622 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go @@ -769,6 +769,15 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xe8 } + if len(m.InetDiagMsgSocketDestNetworkOwner) > 0 { + i -= len(m.InetDiagMsgSocketDestNetworkOwner) + copy(dAtA[i:], m.InetDiagMsgSocketDestNetworkOwner) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InetDiagMsgSocketDestNetworkOwner))) + i-- + dAtA[i] = 0x3f + i-- + dAtA[i] = 0xd2 + } if m.InetDiagMsgInode != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgInode)) i-- @@ -1636,6 +1645,10 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.InetDiagMsgInode != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgInode)) } + l = len(m.InetDiagMsgSocketDestNetworkOwner) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } if m.MemInfoRmem != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.MemInfoRmem)) } @@ -3651,6 +3664,38 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { break } } + case 1018: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketDestNetworkOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InetDiagMsgSocketDestNetworkOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 1101: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MemInfoRmem", wireType) diff --git a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json index 3581513..a4898ae 100644 --- a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json +++ b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json @@ -708,6 +708,18 @@ "populateNsid": { "type": "boolean", "description": "Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for\nDocker/containerd namespaces. Default false." + }, + "enrichAsnEnable": { + "type": "boolean", + "description": "Enrich the destination IP's ASN (field 1011) and network owner (field\n1018) by longest-prefix-matching it against the ipfeed-collector Parquet\nartifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when\nenabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter,\nand leaves both columns empty. Default false." + }, + "asnDbPath": { + "type": "string", + "description": "Path to the ipfeed-collector Parquet artifact (prefix -\u003e {asn,\nnetwork_owner}). Default \"\"." + }, + "asnRefreshInterval": { + "type": "string", + "description": "How often to reload asn_db_path in the background so a refreshed artifact\nis picked up without a restart. 0 = load once at startup, never reload." } }, "title": "xtcp configuration" diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.py b/gen/python/xtcp_config/v1/xtcp_config_pb2.py index a563c26..44f0b05 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.py +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.py @@ -27,7 +27,7 @@ from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf9\x1d\n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12+\n\tmax_loops\x18( \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x32 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x33 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x46 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18P \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12.\n\x0bwrite_files\x18Z \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x64 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12(\n\x07modulus\x18n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12+\n\nmarshal_to\x18x \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\x33\n\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12+\n\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12+\n\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12O\n s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12\x38\n\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n\x04\x64\x65st\x18\x82\x01 \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12\x38\n\x10\x64\x65st_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12#\n\x05topic\x18\x8c\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x35\n\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12\x37\n\x10kafka_schema_url\x18\x91\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12`\n\x15kafka_produce_timeout\x18\x96\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12/\n\x0b\x64\x65\x62ug_level\x18\xa0\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x05label\x18\xaa\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\xb4\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12(\n\x08location\x18\xb5\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12(\n\x08hostname\x18\xb6\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12\x33\n\x0e\x64\x61\x65mon_version\x18\xba\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\x39\n\x14resolve_container_id\x18\xb7\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\'\n\x08ipv4_ttl\x18\xb8\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\xb9\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xbe\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12\x62\n\x15\x65nabled_deserializers\x18\xc8\x01 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12\"\n\x08io_uring\x18\xd2\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x46\n\x18io_uring_recv_batch_size\x18\xd3\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x44\n\x17io_uring_cqe_batch_size\x18\xd4\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12(\n\x0b\x63sv_columns\x18\xdc\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x33\n\x0fpoll_jitter_pct\x18\xdd\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12S\n\x11s3_flush_interval\x18\xde\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12:\n\x13s3_flush_jitter_pct\x18\xdf\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12M\n\x1ds3_flush_threshold_jitter_pct\x18\xe0\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x42\n\x16s3_upload_max_attempts\x18\xe1\x01 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Z\n\x15s3_upload_backoff_cap\x18\xe2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12X\n\x13reconcile_frequency\x18\xe3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x33\n\x15reconcile_before_poll\x18\xe4\x01 \x01(\x08R\x13reconcileBeforePoll\x12\x37\n\x17\x65nrich_container_enable\x18\xe6\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xe7\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xe8\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xe9\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xea\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xeb\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xec\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xed\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xee\x01 \x01(\x08R\x0cpopulateNsid:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x9f\x1f\n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12+\n\tmax_loops\x18( \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x32 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x33 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x46 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18P \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12.\n\x0bwrite_files\x18Z \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x64 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12(\n\x07modulus\x18n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12+\n\nmarshal_to\x18x \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\x33\n\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12+\n\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12+\n\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12O\n s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12\x38\n\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n\x04\x64\x65st\x18\x82\x01 \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12\x38\n\x10\x64\x65st_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12#\n\x05topic\x18\x8c\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x35\n\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12\x37\n\x10kafka_schema_url\x18\x91\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12`\n\x15kafka_produce_timeout\x18\x96\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12/\n\x0b\x64\x65\x62ug_level\x18\xa0\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x05label\x18\xaa\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\xb4\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12(\n\x08location\x18\xb5\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12(\n\x08hostname\x18\xb6\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12\x33\n\x0e\x64\x61\x65mon_version\x18\xba\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\x39\n\x14resolve_container_id\x18\xb7\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\'\n\x08ipv4_ttl\x18\xb8\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\xb9\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xbe\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12\x62\n\x15\x65nabled_deserializers\x18\xc8\x01 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12\"\n\x08io_uring\x18\xd2\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x46\n\x18io_uring_recv_batch_size\x18\xd3\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x44\n\x17io_uring_cqe_batch_size\x18\xd4\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12(\n\x0b\x63sv_columns\x18\xdc\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x33\n\x0fpoll_jitter_pct\x18\xdd\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12S\n\x11s3_flush_interval\x18\xde\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12:\n\x13s3_flush_jitter_pct\x18\xdf\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12M\n\x1ds3_flush_threshold_jitter_pct\x18\xe0\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x42\n\x16s3_upload_max_attempts\x18\xe1\x01 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Z\n\x15s3_upload_backoff_cap\x18\xe2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12X\n\x13reconcile_frequency\x18\xe3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x33\n\x15reconcile_before_poll\x18\xe4\x01 \x01(\x08R\x13reconcileBeforePoll\x12\x37\n\x17\x65nrich_container_enable\x18\xe6\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xe7\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xe8\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xe9\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xea\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xeb\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xec\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xed\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xee\x01 \x01(\x08R\x0cpopulateNsid\x12+\n\x11\x65nrich_asn_enable\x18\xef\x01 \x01(\x08R\x0f\x65nrichAsnEnable\x12)\n\x0b\x61sn_db_path\x18\xf0\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n\x14\x61sn_refresh_interval\x18\xf1\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x12\x61snRefreshInterval:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -179,6 +179,8 @@ _globals['_XTCPCONFIG'].fields_by_name['uplink_count']._serialized_options = b'\272H\004*\002\030\002' _globals['_XTCPCONFIG'].fields_by_name['uplink_interfaces']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['uplink_interfaces']._serialized_options = b'\272H\005\222\001\002\020\002' + _globals['_XTCPCONFIG'].fields_by_name['asn_db_path']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['asn_db_path']._serialized_options = b'\272H\005r\003\030\377\001' _globals['_XTCPCONFIG']._loaded_options = None _globals['_XTCPCONFIG']._serialized_options = b'\272Hp\032n\n\017XtcpConfig.poll\0222Poll timeout must be less than poll poll_frequency\032\'this.poll_frequency > this.poll_timeout' _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._loaded_options = None @@ -226,11 +228,11 @@ _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_start=1846 _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_end=1924 _globals['_XTCPCONFIG']._serialized_start=1927 - _globals['_XTCPCONFIG']._serialized_end=5760 - _globals['_ENABLEDDESERIALIZERS']._serialized_start=5763 - _globals['_ENABLEDDESERIALIZERS']._serialized_end=5922 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=5864 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=5922 - _globals['_CONFIGSERVICE']._serialized_start=5925 - _globals['_CONFIGSERVICE']._serialized_end=6828 + _globals['_XTCPCONFIG']._serialized_end=5926 + _globals['_ENABLEDDESERIALIZERS']._serialized_start=5929 + _globals['_ENABLEDDESERIALIZERS']._serialized_end=6088 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=6030 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=6088 + _globals['_CONFIGSERVICE']._serialized_start=6091 + _globals['_CONFIGSERVICE']._serialized_end=6994 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi index 78b8be1..a5ab2a6 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi @@ -100,7 +100,7 @@ class SetEnvelopeFlushResponse(_message.Message): def __init__(self, config: _Optional[_Union[XtcpConfig, _Mapping]] = ...) -> None: ... class XtcpConfig(_message.Message): - __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "write_files", "capture_path", "modulus", "marshal_to", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "kafka_compression", "s3_endpoint", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_parquet_flush_threshold_bytes", "s3_region", "s3_skip_bucket_probe", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "dest", "dest_write_files", "topic", "xtcp_proto_file", "kafka_schema_url", "kafka_produce_timeout", "debug_level", "label", "tag", "location", "hostname", "daemon_version", "resolve_container_id", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "csv_columns", "poll_jitter_pct", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "reconcile_frequency", "reconcile_before_poll", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid") + __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "write_files", "capture_path", "modulus", "marshal_to", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "kafka_compression", "s3_endpoint", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_parquet_flush_threshold_bytes", "s3_region", "s3_skip_bucket_probe", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "dest", "dest_write_files", "topic", "xtcp_proto_file", "kafka_schema_url", "kafka_produce_timeout", "debug_level", "label", "tag", "location", "hostname", "daemon_version", "resolve_container_id", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "csv_columns", "poll_jitter_pct", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "reconcile_frequency", "reconcile_before_poll", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid", "enrich_asn_enable", "asn_db_path", "asn_refresh_interval") NL_TIMEOUT_MILLISECONDS_FIELD_NUMBER: _ClassVar[int] POLL_FREQUENCY_FIELD_NUMBER: _ClassVar[int] POLL_TIMEOUT_FIELD_NUMBER: _ClassVar[int] @@ -167,6 +167,9 @@ class XtcpConfig(_message.Message): UPLINK_COUNT_FIELD_NUMBER: _ClassVar[int] UPLINK_INTERFACES_FIELD_NUMBER: _ClassVar[int] POPULATE_NSID_FIELD_NUMBER: _ClassVar[int] + ENRICH_ASN_ENABLE_FIELD_NUMBER: _ClassVar[int] + ASN_DB_PATH_FIELD_NUMBER: _ClassVar[int] + ASN_REFRESH_INTERVAL_FIELD_NUMBER: _ClassVar[int] nl_timeout_milliseconds: int poll_frequency: _duration_pb2.Duration poll_timeout: _duration_pb2.Duration @@ -233,7 +236,10 @@ class XtcpConfig(_message.Message): uplink_count: int uplink_interfaces: _containers.RepeatedScalarFieldContainer[str] populate_nsid: bool - def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., modulus: _Optional[int] = ..., marshal_to: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_region: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., dest: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., topic: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., debug_level: _Optional[int] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., location: _Optional[str] = ..., hostname: _Optional[str] = ..., daemon_version: _Optional[str] = ..., resolve_container_id: _Optional[bool] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., csv_columns: _Optional[str] = ..., poll_jitter_pct: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ...) -> None: ... + enrich_asn_enable: bool + asn_db_path: str + asn_refresh_interval: _duration_pb2.Duration + def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., modulus: _Optional[int] = ..., marshal_to: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_region: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., dest: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., topic: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., debug_level: _Optional[int] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., location: _Optional[str] = ..., hostname: _Optional[str] = ..., daemon_version: _Optional[str] = ..., resolve_container_id: _Optional[bool] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., csv_columns: _Optional[str] = ..., poll_jitter_pct: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ..., enrich_asn_enable: _Optional[bool] = ..., asn_db_path: _Optional[str] = ..., asn_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ... class EnabledDeserializers(_message.Message): __slots__ = ("enabled",) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py index cbd0b63..6d57b59 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\x8e<\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n\x1dinet_diag_msg_socket_dest_asn\x18\xf3\x07 \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n!inet_diag_msg_socket_next_hop_asn\x18\xf4\x07 \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x46\n tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12(\n\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x35\n\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n\x1b\x63ongestion_algorithm_string\x18\x94\n \x01(\tR\x19\x63ongestionAlgorithmString\x12t\n\x19\x63ongestion_algorithm_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17\x63ongestionAlgorithmEnum\x12\'\n\x0ftype_of_service\x18\xf9\n \x01(\rR\rtypeOfService\x12$\n\rtraffic_class\x18\xfa\n \x01(\rR\x0ctrafficClass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12-\n\x13sk_mem_info_rcv_buf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvBuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12-\n\x13sk_mem_info_snd_buf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndBuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12&\n\x0eshutdown_state\x18\xc0\x0c \x01(\rR\rshutdownState\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12,\n\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12\x1a\n\x08\x63lass_id\x18\xd1\x0f \x01(\rR\x07\x63lassId\x12\x1a\n\x08sock_opt\x18\xd2\x0f \x01(\rR\x07sockOpt\x12\x18\n\x07\x63_group\x18\xb7\x10 \x01(\x04R\x06\x63Group\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xe3<\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n\x1dinet_diag_msg_socket_dest_asn\x18\xf3\x07 \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n!inet_diag_msg_socket_next_hop_asn\x18\xf4\x07 \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12S\n\'inet_diag_msg_socket_dest_network_owner\x18\xfa\x07 \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x46\n tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12(\n\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x35\n\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n\x1b\x63ongestion_algorithm_string\x18\x94\n \x01(\tR\x19\x63ongestionAlgorithmString\x12t\n\x19\x63ongestion_algorithm_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17\x63ongestionAlgorithmEnum\x12\'\n\x0ftype_of_service\x18\xf9\n \x01(\rR\rtypeOfService\x12$\n\rtraffic_class\x18\xfa\n \x01(\rR\x0ctrafficClass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12-\n\x13sk_mem_info_rcv_buf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvBuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12-\n\x13sk_mem_info_snd_buf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndBuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12&\n\x0eshutdown_state\x18\xc0\x0c \x01(\rR\rshutdownState\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12,\n\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12\x1a\n\x08\x63lass_id\x18\xd1\x0f \x01(\rR\x07\x63lassId\x12\x1a\n\x08sock_opt\x18\xd2\x0f \x01(\rR\x07sockOpt\x12\x18\n\x07\x63_group\x18\xb7\x10 \x01(\x04R\x06\x63Group\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -35,17 +35,17 @@ _globals['_ENVELOPE']._serialized_start=67 _globals['_ENVELOPE']._serialized_end=132 _globals['_XTCPFLATRECORD']._serialized_start=135 - _globals['_XTCPFLATRECORD']._serialized_end=7829 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=7548 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=7829 - _globals['_FLATRECORDSREQUEST']._serialized_start=7831 - _globals['_FLATRECORDSREQUEST']._serialized_end=7851 - _globals['_FLATRECORDSRESPONSE']._serialized_start=7853 - _globals['_FLATRECORDSRESPONSE']._serialized_end=7953 - _globals['_POLLFLATRECORDSREQUEST']._serialized_start=7955 - _globals['_POLLFLATRECORDSREQUEST']._serialized_end=7979 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=7981 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=8085 - _globals['_XTCPFLATRECORDSERVICE']._serialized_start=8088 - _globals['_XTCPFLATRECORDSERVICE']._serialized_end=8325 + _globals['_XTCPFLATRECORD']._serialized_end=7914 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=7633 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=7914 + _globals['_FLATRECORDSREQUEST']._serialized_start=7916 + _globals['_FLATRECORDSREQUEST']._serialized_end=7936 + _globals['_FLATRECORDSRESPONSE']._serialized_start=7938 + _globals['_FLATRECORDSRESPONSE']._serialized_end=8038 + _globals['_POLLFLATRECORDSREQUEST']._serialized_start=8040 + _globals['_POLLFLATRECORDSREQUEST']._serialized_end=8064 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=8066 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=8170 + _globals['_XTCPFLATRECORDSERVICE']._serialized_start=8173 + _globals['_XTCPFLATRECORDSERVICE']._serialized_end=8410 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi index 4cd6611..56fa6c2 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi @@ -14,7 +14,7 @@ class Envelope(_message.Message): def __init__(self, row: _Optional[_Iterable[_Union[XtcpFlatRecord, _Mapping]]] = ...) -> None: ... class XtcpFlatRecord(_message.Message): - __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_delivery_rate_app_limited", "tcp_info_fast_open_client_failed", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rtt_var", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_adv_mss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_not_sent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "congestion_algorithm_string", "congestion_algorithm_enum", "type_of_service", "traffic_class", "sk_mem_info_rmem_alloc", "sk_mem_info_rcv_buf", "sk_mem_info_wmem_alloc", "sk_mem_info_snd_buf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "shutdown_state", "vegas_info_enabled", "vegas_info_rtt_cnt", "vegas_info_rtt", "vegas_info_min_rtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "class_id", "sock_opt", "c_group") + __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "inet_diag_msg_socket_dest_network_owner", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_delivery_rate_app_limited", "tcp_info_fast_open_client_failed", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rtt_var", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_adv_mss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_not_sent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "congestion_algorithm_string", "congestion_algorithm_enum", "type_of_service", "traffic_class", "sk_mem_info_rmem_alloc", "sk_mem_info_rcv_buf", "sk_mem_info_wmem_alloc", "sk_mem_info_snd_buf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "shutdown_state", "vegas_info_enabled", "vegas_info_rtt_cnt", "vegas_info_rtt", "vegas_info_min_rtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "class_id", "sock_opt", "c_group") class CongestionAlgorithm(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CONGESTION_ALGORITHM_UNSPECIFIED: _ClassVar[XtcpFlatRecord.CongestionAlgorithm] @@ -93,6 +93,7 @@ class XtcpFlatRecord(_message.Message): INET_DIAG_MSG_WQUEUE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_UID_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_INODE_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_MSG_SOCKET_DEST_NETWORK_OWNER_FIELD_NUMBER: _ClassVar[int] MEM_INFO_RMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_WMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_FMEM_FIELD_NUMBER: _ClassVar[int] @@ -249,6 +250,7 @@ class XtcpFlatRecord(_message.Message): inet_diag_msg_wqueue: int inet_diag_msg_uid: int inet_diag_msg_inode: int + inet_diag_msg_socket_dest_network_owner: str mem_info_rmem: int mem_info_wmem: int mem_info_fmem: int @@ -345,7 +347,7 @@ class XtcpFlatRecord(_message.Message): class_id: int sock_opt: int c_group: int - def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_socket_dest_asn: _Optional[int] = ..., inet_diag_msg_socket_next_hop_asn: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_send_scale: _Optional[int] = ..., tcp_info_rcv_scale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fast_open_client_failed: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rtt_var: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_adv_mss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_not_sent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., congestion_algorithm_string: _Optional[str] = ..., congestion_algorithm_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., type_of_service: _Optional[int] = ..., traffic_class: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcv_buf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_snd_buf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., shutdown_state: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rtt_cnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_min_rtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., class_id: _Optional[int] = ..., sock_opt: _Optional[int] = ..., c_group: _Optional[int] = ...) -> None: ... + def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_socket_dest_asn: _Optional[int] = ..., inet_diag_msg_socket_next_hop_asn: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., inet_diag_msg_socket_dest_network_owner: _Optional[str] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_send_scale: _Optional[int] = ..., tcp_info_rcv_scale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fast_open_client_failed: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rtt_var: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_adv_mss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_not_sent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., congestion_algorithm_string: _Optional[str] = ..., congestion_algorithm_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., type_of_service: _Optional[int] = ..., traffic_class: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcv_buf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_snd_buf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., shutdown_state: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rtt_cnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_min_rtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., class_id: _Optional[int] = ..., sock_opt: _Optional[int] = ..., c_group: _Optional[int] = ...) -> None: ... class FlatRecordsRequest(_message.Message): __slots__ = () diff --git a/go.mod b/go.mod index 3e2c947..9881093 100644 --- a/go.mod +++ b/go.mod @@ -1,17 +1,17 @@ module github.com/randomizedcoder/xtcp2 -go 1.25 - +go 1.25.0 require ( buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.6-20250307204501-0409229c3780.1 github.com/bufbuild/protovalidate-go v0.9.3 + github.com/gaissmai/bart v0.29.0 github.com/grafana/pyroscope-go v1.3.0 - github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 - github.com/minio/minio-go/v7 v7.1.0 + github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 + github.com/minio/minio-go/v7 v7.3.0 github.com/nats-io/nats.go v1.41.1 github.com/nsqio/go-nsq v1.1.0 - github.com/parquet-go/parquet-go v0.30.1 + github.com/parquet-go/parquet-go v0.32.0 github.com/pkg/profile v1.7.0 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 github.com/prometheus/client_golang v1.22.0 @@ -22,29 +22,39 @@ require ( github.com/twmb/franz-go/pkg/sr v1.3.0 github.com/twmb/franz-go/plugin/kprom v1.2.0 github.com/vmihailenco/msgpack/v5 v5.4.1 - golang.org/x/sys v0.39.0 - google.golang.org/genproto/googleapis/api v0.0.0-20250409194420-de1ac958c67a - google.golang.org/grpc v1.71.1 - google.golang.org/protobuf v1.36.6 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 + go.opentelemetry.io/otel/metric v1.46.0 + go.opentelemetry.io/otel/sdk v1.46.0 + go.opentelemetry.io/otel/sdk/metric v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 + go.yaml.in/yaml/v3 v3.0.5 + golang.org/x/sys v0.47.0 + google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 + google.golang.org/grpc v1.83.1 + google.golang.org/protobuf v1.36.12 ) require ( - cel.dev/expr v0.23.1 // indirect + cel.dev/expr v0.25.2 // indirect github.com/andybalholm/brotli v1.1.1 // indirect github.com/antlr4-go/antlr/v4 v4.13.1 // indirect github.com/beorn7/perks v1.0.1 // indirect + github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/felixge/fgprof v0.9.5 // indirect - github.com/go-ini/ini v1.67.0 // indirect + github.com/go-logr/logr v1.4.4 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/snappy v1.0.0 // indirect github.com/google/cel-go v0.24.1 // indirect github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 // indirect github.com/google/uuid v1.6.0 // indirect github.com/grafana/pyroscope-go/godeltaprof v0.1.10 // indirect - github.com/klauspost/compress v1.18.6 // indirect - github.com/klauspost/cpuid/v2 v2.2.11 // indirect + github.com/klauspost/compress v1.19.2 // indirect + github.com/klauspost/cpuid/v2 v2.4.0 // indirect github.com/klauspost/crc32 v1.3.0 // indirect github.com/kylelemons/godebug v1.1.0 // indirect github.com/minio/crc64nvme v1.1.1 // indirect @@ -60,17 +70,20 @@ require ( github.com/prometheus/procfs v0.16.0 // indirect github.com/rs/xid v1.6.0 // indirect github.com/stoewer/go-strcase v1.3.0 // indirect - github.com/tinylib/msgp v1.6.1 // indirect + github.com/tinylib/msgp v1.6.4 // indirect github.com/twmb/franz-go/pkg/kmsg v1.11.1 // indirect github.com/twpayne/go-geom v1.6.1 // indirect github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect github.com/zeebo/xxh3 v1.1.0 // indirect - go.yaml.in/yaml/v3 v3.0.4 // indirect - golang.org/x/crypto v0.46.0 // indirect + go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 // indirect + go.opentelemetry.io/proto/otlp v1.11.0 // indirect + golang.org/x/crypto v0.55.0 // indirect golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect - golang.org/x/net v0.48.0 // indirect - golang.org/x/text v0.32.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250409194420-de1ac958c67a // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect + gopkg.in/ini.v1 v1.67.3 // indirect ) replace github.com/randomizedcoder/giouring => /home/das/Downloads/giouring diff --git a/go.sum b/go.sum index 7e60714..6a298a4 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,7 @@ buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.6-20250307204501-0409229c3780.1 h1:zgJPqo17m28+Lf5BW4xv3PvU20BnrmTcGYrog22lLIU= buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.6-20250307204501-0409229c3780.1/go.mod h1:avRlCjnFzl98VPaeCtJ24RrV/wwHFzB8sWXhj26+n/U= -cel.dev/expr v0.23.1 h1:K4KOtPCJQjVggkARsjG9RWXP6O4R73aHeJMa/dmCQQg= -cel.dev/expr v0.23.1/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw= +cel.dev/expr v0.25.2 h1:K6j46C81hXtZQfuX60cVWQFBJahKSE2gfRbNuvr5bFs= +cel.dev/expr v0.25.2/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= github.com/alecthomas/assert/v2 v2.10.0 h1:jjRCHsj6hBJhkmhznrCzoNpbA3zqy0fYiUcYZP/GkPY= @@ -20,6 +20,8 @@ github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= github.com/bufbuild/protovalidate-go v0.9.3 h1:XvdtwQuppS3wjzGfpOirsqwN5ExH2+PiIuA/XZd3MTM= github.com/bufbuild/protovalidate-go v0.9.3/go.mod h1:2lUDP6fNd3wxznRNH3Nj64VB07+PySeslamkerwP6tE= +github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= +github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chromedp/cdproto v0.0.0-20230802225258-3cf4e6d46a89/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs= @@ -32,21 +34,21 @@ github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObk github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/envoyproxy/protoc-gen-validate v1.2.1 h1:DEo3O99U8j4hBFwbJfrz9VtgcDfUKS7KJ7spH3d86P8= -github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU= +github.com/envoyproxy/protoc-gen-validate v1.3.3 h1:MVQghNeW+LZcmXe7SY1V36Z+WFMDjpqGAGacLe2T0ds= +github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDDHINPLWB7C82oDArY51KfB0= github.com/felixge/fgprof v0.9.3/go.mod h1:RdbpDgzqYVh/T9fPELJyV7EYJuHB55UTEULNun8eiPw= github.com/felixge/fgprof v0.9.5 h1:8+vR6yu2vvSKn08urWyEuxx75NWPEvybbkBirEpsbVY= github.com/felixge/fgprof v0.9.5/go.mod h1:yKl+ERSa++RYOs32d8K6WEXCB4uXdLls4ZaZPpayhMM= -github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= -github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= -github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= -github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/gaissmai/bart v0.29.0 h1:wO6HGE8g9YE0Wm0bCpYxwRzfQ4+fbJKOhL64e5ACGCI= +github.com/gaissmai/bart v0.29.0/go.mod h1:GREWQfTLRWz/c5FTOsIw+KkscuFkIV5t8Rp7Nd1Td5c= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM= @@ -71,24 +73,20 @@ github.com/grafana/pyroscope-go v1.3.0 h1:t3Jehad8vvqN4oRAB0LdmfQ5ZSUXQw3asoft+K github.com/grafana/pyroscope-go v1.3.0/go.mod h1:XA7I3usNx+UdjOZfQnl1WV8y924vsJo9KIVrKB+9jx4= github.com/grafana/pyroscope-go/godeltaprof v0.1.10 h1:dvhndEbyavTb59vFCd6PsrAG5qi69/qZZtegh/TJKSY= github.com/grafana/pyroscope-go/godeltaprof v0.1.10/go.mod h1:XnWRGg2XO5uxZdiz1rfeJH6w1eZ+YICCBVXNWOfH86g= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 h1:/Tnpcb2E0Pz/tN9s3bfEY2Q8ePCEX9iuS+cneUwncnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0/go.mod h1:zOBXOsUaBSjKgmH4OGzV1esUpR3oUSCPYVd2cUBjKYY= github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= github.com/ianlancetaylor/demangle v0.0.0-20230524184225-eabc099b10ab/go.mod h1:gx7rwoVhcfuVKG5uya9Hs3Sxj7EIvldVofAWIUtGouw= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU= -github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= +github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM= github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs= @@ -97,8 +95,8 @@ github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= -github.com/minio/minio-go/v7 v7.1.0 h1:QEt5IStDpxgGjEdtOgpiZ5QhmSl3ax7qy61vi2SwHO8= -github.com/minio/minio-go/v7 v7.1.0/go.mod h1:Dm7WS1AgLmBa0NcQD6SeJnJf+K/EUW3GR7Ks6olB3OA= +github.com/minio/minio-go/v7 v7.3.0 h1:HM4pFCSQq/TK+j0/zmorSh5ddh81iDgRgU0BG0Vz/YU= +github.com/minio/minio-go/v7 v7.3.0/go.mod h1:KUPWdecEO1LWyUz+sTGXAuf2jZHrPh5fCsRH86QbPfk= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/nats-io/nats.go v1.41.1 h1:lCc/i5x7nqXbspxtmXaV4hRguMPHqE/kYltG9knrCdU= @@ -114,8 +112,8 @@ github.com/parquet-go/bitpack v1.0.0 h1:AUqzlKzPPXf2bCdjfj4sTeacrUwsT7NlcYDMUQxP github.com/parquet-go/bitpack v1.0.0/go.mod h1:XnVk9TH+O40eOOmvpAVZ7K2ocQFrQwysLMnc6M/8lgs= github.com/parquet-go/jsonlite v1.0.0 h1:87QNdi56wOfsE5bdgas0vRzHPxfJgzrXGml1zZdd7VU= github.com/parquet-go/jsonlite v1.0.0/go.mod h1:nDjpkpL4EOtqs6NQugUsi0Rleq9sW/OtC1NnZEnxzF0= -github.com/parquet-go/parquet-go v0.30.1 h1:Oy6ganNrAdFiVwy7wNmWagfPTWA2X9Z3tVHBc7JtuX8= -github.com/parquet-go/parquet-go v0.30.1/go.mod h1:navtkAYr2LGoJVp141oXPlO/sxLvaOe3la2JEoD8+rg= +github.com/parquet-go/parquet-go v0.32.0 h1:NWDqTUHfrCS4cJP/Fj2HlxvqsrVedWG3sayMkf+znzM= +github.com/parquet-go/parquet-go v0.32.0/go.mod h1:navtkAYr2LGoJVp141oXPlO/sxLvaOe3la2JEoD8+rg= github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU= @@ -124,7 +122,6 @@ github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA= github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q= github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0= @@ -136,8 +133,6 @@ github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2b github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg= github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM= github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= -github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= -github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs= @@ -150,10 +145,12 @@ github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -github.com/tinylib/msgp v1.6.1 h1:ESRv8eL3u+DNHUoSAAQRE50Hm162zqAnBoGv9PzScPY= -github.com/tinylib/msgp v1.6.1/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ= +github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= github.com/twmb/franz-go v1.18.1 h1:D75xxCDyvTqBSiImFx2lkPduE39jz1vaD7+FNc+vMkc= github.com/twmb/franz-go v1.18.1/go.mod h1:Uzo77TarcLTUZeLuGq+9lNpSkfZI+JErv7YJhlDjs9M= github.com/twmb/franz-go/pkg/kmsg v1.11.1 h1:cuW0wIrdZJQ8NZ5ba+jq0OIOdpP0yuRjPeuE8eYodZw= @@ -174,44 +171,58 @@ github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ= github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= -go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= -go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= -go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY= -go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI= -go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ= -go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE= -go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A= -go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU= -go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk= -go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w= -go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k= -go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= -golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU= -golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 h1:AP23h/mFgb/lc7tdck1Kfn9qxsM8TAeNPCU5C3pzaps= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0/go.mod h1:K4EqCe1b4kGk5WR690ntg9LaBfsPoV32FwthbyoptuA= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 h1:OFnwLJr+pF3iHrlGSzbxyuo6/6HyBlnlN1CWEJmBVcw= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0/go.mod h1:716wFneO0ov19A2beH5hjfh9AK5z/VWNAtDijp1Y0/g= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 h1:KrC1YrQeSt46ITMWAbgQx1M1eV1/1TKzttrBzymPmss= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0/go.mod h1:zDSEzoEqsOrgBeGvH66KRgxh90VonFyJqBHA0Pk3+rM= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= +go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= +go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk= +go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= -golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU= -golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk= -golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU= -golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY= -google.golang.org/genproto/googleapis/api v0.0.0-20250409194420-de1ac958c67a h1:OQ7sHVzkx6L57dQpzUS4ckfWJ51KDH74XHTDe23xWAs= -google.golang.org/genproto/googleapis/api v0.0.0-20250409194420-de1ac958c67a/go.mod h1:2R6XrVC8Oc08GlNh8ujEpc7HkLiEZ16QeY7FxIs20ac= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250409194420-de1ac958c67a h1:GIqLhp/cYUkuGuiT+vJk8vhOP86L4+SP5j8yXgeVpvI= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250409194420-de1ac958c67a/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= -google.golang.org/grpc v1.71.1 h1:ffsFWr7ygTUscGPI0KKK6TLrGz0476KUvvsbqWK0rPI= -google.golang.org/grpc v1.71.1/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec= -google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= -google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= +gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= +google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 h1:ax2KzoSRIZU/M0cIxri3pKxy99vniH1PVxWC6si/eZI= +google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688/go.mod h1:1RJ9BQGyNdZwkGc1eTqkErfRZ6RJyYPHZo73BZ1vQqI= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 h1:cYNAzI2sUwhmCcoj9TxvihSrqsxt6uIkj3rDRhSDmW4= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw= +gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/ipfeed/asnmap/asnmap.go b/internal/ipfeed/asnmap/asnmap.go new file mode 100644 index 0000000..57853b9 --- /dev/null +++ b/internal/ipfeed/asnmap/asnmap.go @@ -0,0 +1,64 @@ +// Package asnmap maps a feed's network owner / provider name to a +// representative BGP autonomous-system number (ASN). +// +// The IP-range feeds ipfeed-collector parses identify the owning provider of a +// prefix (network_owner / provider), not its BGP origin ASN. For coarse +// enrichment we map each well-known provider to its primary public ASN using +// the small curated table below. +// +// IMPORTANT — this is a *representative* ASN, not a per-prefix BGP-origin ASN. +// Large providers announce prefixes from several ASNs (e.g. AWS also uses +// AS14618/AS8987; Google also AS36040/AS36384), so a name→ASN map is lossy by +// design. True per-prefix origin (and next-hop) ASN requires a BGP RIB (MRT) +// source, which is a separate, later phase. Values here are best-effort and +// intended to be easy to extend as feeds are added. +package asnmap + +import ( + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// table maps a normalized (lowercased) owner/provider name to its +// representative ASN. Keys cover both the network_owner and provider spellings +// that appear in sources/*.yaml. +var table = map[string]uint32{ + "google": 15169, // Google LLC + "gcp": 15169, + "microsoft": 8075, // Microsoft Corporation + "azure": 8075, + "aws": 16509, // Amazon.com (primary; AWS also uses 14618, 8987, …) + "amazon": 16509, + "cloudflare": 13335, // Cloudflare, Inc. + "fastly": 54113, // Fastly, Inc. + "apple": 714, // Apple Inc. + "digitalocean": 14061, // DigitalOcean, LLC + "github": 36459, // GitHub, Inc. + "oracle": 31898, // Oracle Cloud (OCI) + "salesforce": 14340, // Salesforce.com, Inc. + "atlassian": 133530, // Atlassian Pty Ltd +} + +// Lookup returns the representative ASN for an owner/provider pair. It tries +// networkOwner first, then provider; names are matched case-insensitively. +// The bool is false (and asn 0) when neither name is known. +func Lookup(networkOwner, provider string) (uint32, bool) { + if asn, ok := table[strings.ToLower(strings.TrimSpace(networkOwner))]; ok { + return asn, true + } + if asn, ok := table[strings.ToLower(strings.TrimSpace(provider))]; ok { + return asn, true + } + return 0, false +} + +// Annotate sets r.ASN for every record whose owner/provider maps to a known +// ASN, leaving the rest at 0. It mutates records in place. +func Annotate(records []model.Record) { + for i := range records { + if asn, ok := Lookup(records[i].NetworkOwner, records[i].Provider); ok { + records[i].ASN = asn + } + } +} diff --git a/internal/ipfeed/asnmap/asnmap_test.go b/internal/ipfeed/asnmap/asnmap_test.go new file mode 100644 index 0000000..0ae0cd3 --- /dev/null +++ b/internal/ipfeed/asnmap/asnmap_test.go @@ -0,0 +1,57 @@ +package asnmap + +import ( + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// TestLookup covers owner/provider resolution, precedence, and misses. +func TestLookup(t *testing.T) { + tests := []struct { + name, desc, class string + owner, provider string + wantASN uint32 + wantOK bool + }{ + {"positive_owner", "positive: a known network_owner resolves", "positive", + "cloudflare", "", 13335, true}, + {"positive_provider_fallback", "positive: falls back to provider when owner is empty", "positive", + "", "gcp", 15169, true}, + {"boundary_owner_precedence", "boundary: owner is tried before provider", "boundary", + "fastly", "aws", 54113, true}, + {"corner_case_insensitive", "corner: matching is case- and space-insensitive", "corner", + " Cloudflare ", "", 13335, true}, + {"negative_unknown", "negative: an unknown name yields (0,false)", "negative", + "acme-corp", "acme-corp", 0, false}, + {"boundary_both_empty", "boundary: empty owner and provider is a miss", "boundary", + "", "", 0, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + gotASN, gotOK := Lookup(tc.owner, tc.provider) + if gotASN != tc.wantASN || gotOK != tc.wantOK { + t.Errorf("%s: Lookup(%q,%q) = (%d,%v), want (%d,%v)", + tc.desc, tc.owner, tc.provider, gotASN, gotOK, tc.wantASN, tc.wantOK) + } + }) + } +} + +// TestAnnotate verifies in-place ASN annotation across known and unknown owners. +func TestAnnotate(t *testing.T) { + recs := []model.Record{ + {Prefix: "1.1.1.0/24", NetworkOwner: "cloudflare"}, // known + {Prefix: "8.8.8.0/24", Provider: "gcp"}, // known via provider + {Prefix: "10.0.0.0/24", NetworkOwner: "acme"}, // unknown -> 0 + {Prefix: "192.0.2.0/24", NetworkOwner: "", Provider: ""}, // empty -> 0 + } + Annotate(recs) + + want := []uint32{13335, 15169, 0, 0} + for i, w := range want { + if recs[i].ASN != w { + t.Errorf("record %d (%s): ASN = %d, want %d", i, recs[i].Prefix, recs[i].ASN, w) + } + } +} diff --git a/internal/ipfeed/combine/combine.go b/internal/ipfeed/combine/combine.go new file mode 100644 index 0000000..e94310b --- /dev/null +++ b/internal/ipfeed/combine/combine.go @@ -0,0 +1,85 @@ +// Package combine validates parsed records and aggregates them into the final +// dataset, tracking the positive/negative boundaries: a "positive" record has +// a valid CIDR and is kept; a "negative" record is rejected and counted with a +// bounded reason so downstream metric cardinality stays safe. +package combine + +import ( + "net/netip" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// RejectReason is a closed set of rejection categories. It is deliberately a +// small enum (never raw error text) so it is safe to use as a metric label. +type RejectReason string + +const ( + ReasonParseError RejectReason = "ParseError" // prefix failed net/netip.ParsePrefix + ReasonEmpty RejectReason = "Empty" // empty prefix string + ReasonDuplicate RejectReason = "Duplicate" // identical record already seen + ReasonSourceFailed RejectReason = "SourceFailed" // whole source failed upstream +) + +// Rejected is one dropped record with its reason. +type Rejected struct { + Record model.Record + Reason RejectReason +} + +// Result holds the outcome of combining one source's parsed rows. +type Result struct { + Valid []model.Record // positive (+) boundary + Rejected []Rejected // negative (-) boundary +} + +// ValidCount returns the positive-boundary count. +func (r Result) ValidCount() int { return len(r.Valid) } + +// RejectedCount returns the negative-boundary count. +func (r Result) RejectedCount() int { return len(r.Rejected) } + +// dedupKey identifies a record for duplicate detection. Prefix plus the +// classification fields — the same prefix under a different service/region is +// intentionally kept (overlapping classifications are meaningful). +func dedupKey(r model.Record) string { + return r.Prefix + "|" + r.NetworkOwner + "|" + r.ServiceOperator + "|" + + r.Service + "|" + r.Product + "|" + r.Region + "|" + r.Direction + "|" + r.SourceName +} + +// Validate canonicalizes and validates records from a single source. seen is a +// cross-source set so identical records from overlapping feeds are counted as +// duplicates once. Each input record's Prefix is parsed; on success the +// canonical form and ip_version are written back and the record is kept. +func Validate(records []model.Record, seen map[string]struct{}) Result { + var res Result + for i := range records { + r := records[i] // local copy: canonicalization must not mutate the caller's slice + if r.Prefix == "" { + res.Rejected = append(res.Rejected, Rejected{Record: r, Reason: ReasonEmpty}) + continue + } + p, err := netip.ParsePrefix(r.Prefix) + if err != nil { + res.Rejected = append(res.Rejected, Rejected{Record: r, Reason: ReasonParseError}) + continue + } + // Canonicalize: masked prefix + normalized address text. This turns a + // host-bits-set input like 1.2.3.4/24 into 1.2.3.0/24. + p = p.Masked() + r.Prefix = p.String() + if p.Addr().Is4() { + r.IPVersion = 4 + } else { + r.IPVersion = 6 + } + key := dedupKey(r) + if _, dup := seen[key]; dup { + res.Rejected = append(res.Rejected, Rejected{Record: r, Reason: ReasonDuplicate}) + continue + } + seen[key] = struct{}{} + res.Valid = append(res.Valid, r) + } + return res +} diff --git a/internal/ipfeed/combine/combine_bench_test.go b/internal/ipfeed/combine/combine_bench_test.go new file mode 100644 index 0000000..d3dcefa --- /dev/null +++ b/internal/ipfeed/combine/combine_bench_test.go @@ -0,0 +1,43 @@ +package combine + +import ( + "fmt" + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// genRecords builds n unique, canonical /24 records. The first octet spans +// 10..73 and the next two span 0..255, giving ~4.19M distinct /24s so no +// dedup collisions occur at the sizes benchmarked. +func genRecords(n int) []model.Record { + recs := make([]model.Record, n) + for i := range n { + recs[i] = model.Record{ + Prefix: fmt.Sprintf("%d.%d.%d.0/24", 10+((i>>16)&0x3f), (i>>8)&0xff, i&0xff), + SourceName: "bench", + Provider: "bench", + } + } + return recs +} + +// BenchmarkValidate measures the combine hot path (netip.ParsePrefix + +// Masked() canonicalization + dedup map) across dataset sizes. A fresh seen +// map is allocated per iteration since Validate mutates it. +func BenchmarkValidate(b *testing.B) { + for _, size := range []int{100, 10_000, 100_000} { + recs := genRecords(size) + b.Run(fmt.Sprintf("n=%d", size), func(b *testing.B) { + b.ReportAllocs() + b.ResetTimer() + for range b.N { + seen := make(map[string]struct{}, size) + res := Validate(recs, seen) + if res.ValidCount() != size { + b.Fatalf("valid=%d, want %d", res.ValidCount(), size) + } + } + }) + } +} diff --git a/internal/ipfeed/combine/combine_test.go b/internal/ipfeed/combine/combine_test.go new file mode 100644 index 0000000..d48427a --- /dev/null +++ b/internal/ipfeed/combine/combine_test.go @@ -0,0 +1,137 @@ +package combine + +import ( + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// TestValidate is table-driven and covers positive, negative, boundary, and +// corner cases for CIDR validation and the positive/negative boundary counts. +func TestValidate(t *testing.T) { + tests := []struct { + name string + desc string // what this row exercises + case class + class string + in []model.Record + wantValid []string // canonical prefixes expected in output (in order) + wantVer []int32 // ip_version expected, parallel to wantValid + wantReject []RejectReason // rejection reasons expected (in order) + }{ + { + name: "valid_v4", + desc: "positive: a normal IPv4 /24 is kept and canonical", + class: "positive", + in: []model.Record{{Prefix: "13.248.0.0/16"}}, + wantValid: []string{"13.248.0.0/16"}, + wantVer: []int32{4}, + }, + { + name: "valid_v6", + desc: "positive: a normal IPv6 prefix is kept with version 6", + class: "positive", + in: []model.Record{{Prefix: "2600:1f00::/24"}}, + wantValid: []string{"2600:1f00::/24"}, + wantVer: []int32{6}, + }, + { + name: "boundary_default_route_and_host", + desc: "boundary: /0 and /32 edges are valid", + class: "boundary", + in: []model.Record{{Prefix: "0.0.0.0/0"}, {Prefix: "1.2.3.4/32"}}, + wantValid: []string{"0.0.0.0/0", "1.2.3.4/32"}, + wantVer: []int32{4, 4}, + }, + { + name: "boundary_v6_full_length", + desc: "boundary: a /128 single-address IPv6 prefix is valid", + class: "boundary", + in: []model.Record{{Prefix: "2001:db8::1/128"}}, + wantValid: []string{"2001:db8::1/128"}, + wantVer: []int32{6}, + }, + { + name: "negative_empty", + desc: "negative: an empty prefix is rejected as Empty", + class: "negative", + in: []model.Record{{Prefix: ""}}, + wantReject: []RejectReason{ReasonEmpty}, + }, + { + name: "negative_garbage", + desc: "negative: non-CIDR text is rejected as ParseError", + class: "negative", + in: []model.Record{{Prefix: "not-a-cidr"}}, + wantReject: []RejectReason{ReasonParseError}, + }, + { + name: "negative_bad_mask", + desc: "negative: an out-of-range mask /33 is rejected", + class: "negative", + in: []model.Record{{Prefix: "10.0.0.0/33"}}, + wantReject: []RejectReason{ReasonParseError}, + }, + { + name: "negative_bare_ip", + desc: "negative: a bare IP with no mask is rejected (ParsePrefix needs a /)", + class: "negative", + in: []model.Record{{Prefix: "1.2.3.4"}}, + wantReject: []RejectReason{ReasonParseError}, + }, + { + name: "corner_noncanonical", + desc: "corner: host bits set are masked to the canonical network", + class: "corner", + in: []model.Record{{Prefix: "1.2.3.4/24"}}, + wantValid: []string{"1.2.3.0/24"}, + wantVer: []int32{4}, + }, + { + name: "corner_duplicate", + desc: "corner: an identical record is kept once, second is Duplicate", + class: "corner", + in: []model.Record{{Prefix: "8.8.8.0/24"}, {Prefix: "8.8.8.0/24"}}, + wantValid: []string{"8.8.8.0/24"}, + wantVer: []int32{4}, + wantReject: []RejectReason{ReasonDuplicate}, + }, + { + name: "corner_same_prefix_diff_service_kept", + desc: "corner: same prefix under a different service is not a duplicate", + class: "corner", + in: []model.Record{ + {Prefix: "8.8.8.0/24", Service: "a"}, + {Prefix: "8.8.8.0/24", Service: "b"}, + }, + wantValid: []string{"8.8.8.0/24", "8.8.8.0/24"}, + wantVer: []int32{4, 4}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + seen := map[string]struct{}{} + got := Validate(tc.in, seen) + + if len(got.Valid) != len(tc.wantValid) { + t.Fatalf("%s: valid count = %d, want %d", tc.desc, len(got.Valid), len(tc.wantValid)) + } + for i, want := range tc.wantValid { + if got.Valid[i].Prefix != want { + t.Errorf("%s: valid[%d].Prefix = %q, want %q", tc.desc, i, got.Valid[i].Prefix, want) + } + if got.Valid[i].IPVersion != tc.wantVer[i] { + t.Errorf("%s: valid[%d].IPVersion = %d, want %d", tc.desc, i, got.Valid[i].IPVersion, tc.wantVer[i]) + } + } + if len(got.Rejected) != len(tc.wantReject) { + t.Fatalf("%s: rejected count = %d, want %d", tc.desc, len(got.Rejected), len(tc.wantReject)) + } + for i, want := range tc.wantReject { + if got.Rejected[i].Reason != want { + t.Errorf("%s: rejected[%d].Reason = %q, want %q", tc.desc, i, got.Rejected[i].Reason, want) + } + } + }) + } +} diff --git a/internal/ipfeed/config/source.go b/internal/ipfeed/config/source.go new file mode 100644 index 0000000..fa3ec6c --- /dev/null +++ b/internal/ipfeed/config/source.go @@ -0,0 +1,145 @@ +// Package config loads and validates source definitions. Each feed is one +// YAML file in a sources directory, which keeps sources easy to add, remove, +// and review individually, and lets the collector fan work out across files. +package config + +import ( + "fmt" + "os" + "path/filepath" + "sort" + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/parse" + "go.yaml.in/yaml/v3" +) + +// Defaults mirror parse.Defaults for YAML decoding. +type Defaults struct { + NetworkOwner string `yaml:"network_owner"` + ServiceOperator string `yaml:"service_operator"` + Service string `yaml:"service"` + Product string `yaml:"product"` + Region string `yaml:"region"` + Direction string `yaml:"direction"` +} + +// Source is one feed definition, decoded from a single YAML file. +type Source struct { + Name string `yaml:"name"` + Provider string `yaml:"provider"` + URL string `yaml:"url"` + Parser string `yaml:"parser"` + SourceType string `yaml:"source_type"` + Confidence string `yaml:"confidence"` + Defaults Defaults `yaml:"defaults"` + Discover string `yaml:"discover"` + ParserOpts map[string]any `yaml:"parser_opts"` + Enabled *bool `yaml:"enabled"` + + // Path is the file the source was loaded from (for diagnostics). Not from YAML. + Path string `yaml:"-"` +} + +// IsEnabled reports whether the source should run. Absent `enabled:` means +// enabled, so a new file is active by default. +func (s Source) IsEnabled() bool { return s.Enabled == nil || *s.Enabled } + +// Meta projects a Source onto the subset the parse package needs. +func (s Source) Meta() parse.SourceMeta { + return parse.SourceMeta{ + Name: s.Name, + Provider: s.Provider, + URL: s.URL, + SourceType: s.SourceType, + Confidence: s.Confidence, + Defaults: parse.Defaults{ + NetworkOwner: s.Defaults.NetworkOwner, + ServiceOperator: s.Defaults.ServiceOperator, + Service: s.Defaults.Service, + Product: s.Defaults.Product, + Region: s.Defaults.Region, + Direction: s.Defaults.Direction, + }, + Opts: s.ParserOpts, + } +} + +// validate checks required fields and that the parser key is known. +func (s Source) validate() error { + var missing []string + if s.Name == "" { + missing = append(missing, "name") + } + if s.URL == "" { + missing = append(missing, "url") + } + if s.Parser == "" { + missing = append(missing, "parser") + } + if len(missing) > 0 { + return fmt.Errorf("missing required field(s): %s", strings.Join(missing, ", ")) + } + if !parse.Registered(s.Parser) { + known := parse.Names() + sort.Strings(known) + return fmt.Errorf("unknown parser %q (known: %s)", s.Parser, strings.Join(known, ", ")) + } + if s.Discover != "" && s.Discover != "none" && s.Discover != "azure_download_page" { + return fmt.Errorf("unknown discover mode %q", s.Discover) + } + return nil +} + +// LoadFile parses and validates a single source file. +func LoadFile(path string) (Source, error) { + b, err := os.ReadFile(path) + if err != nil { + return Source{}, err + } + var s Source + dec := yaml.NewDecoder(strings.NewReader(string(b))) + dec.KnownFields(true) // reject typo'd/unknown keys + if err := dec.Decode(&s); err != nil { + return Source{}, fmt.Errorf("decode %s: %w", path, err) + } + s.Path = path + if err := s.validate(); err != nil { + return Source{}, fmt.Errorf("%s: %w", path, err) + } + return s, nil +} + +// LoadDir loads every *.yaml / *.yml file in dir, returning only enabled +// sources sorted by name. A parse/validation error in any file is returned so +// a broken config fails fast rather than silently dropping a feed. +func LoadDir(dir string) ([]Source, error) { + var paths []string + for _, pat := range []string{"*.yaml", "*.yml"} { + m, err := filepath.Glob(filepath.Join(dir, pat)) + if err != nil { + return nil, err + } + paths = append(paths, m...) + } + sort.Strings(paths) + + var out []Source + seen := map[string]string{} // name -> path, to catch duplicate names + for _, p := range paths { + s, err := LoadFile(p) + if err != nil { + return nil, err + } + if prev, dup := seen[s.Name]; dup { + return nil, fmt.Errorf("duplicate source name %q in %s and %s", s.Name, prev, p) + } + seen[s.Name] = p + if !s.IsEnabled() { + continue + } + out = append(out, s) + } + sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name }) + return out, nil +} diff --git a/internal/ipfeed/config/source_test.go b/internal/ipfeed/config/source_test.go new file mode 100644 index 0000000..ca9ce46 --- /dev/null +++ b/internal/ipfeed/config/source_test.go @@ -0,0 +1,94 @@ +package config + +import ( + "os" + "path/filepath" + "testing" + + // Import parse so its parsers register via init(), making parser keys like + // "text_cidr" valid during config validation. + _ "github.com/randomizedcoder/xtcp2/internal/ipfeed/parse" +) + +func writeFile(t *testing.T, dir, name, body string) string { + t.Helper() + p := filepath.Join(dir, name) + if err := os.WriteFile(p, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + return p +} + +func TestLoadFile(t *testing.T) { + tests := []struct { + name string + desc string + class string + body string + wantErr bool + }{ + {"positive_valid", "positive: a complete valid source loads", "positive", + "name: cf\nprovider: cloudflare\nurl: https://x/y\nparser: text_cidr\n", false}, + {"negative_missing_url", "negative: a missing required field (url) errors", "negative", + "name: cf\nprovider: cloudflare\nparser: text_cidr\n", true}, + {"negative_unknown_parser", "negative: an unregistered parser key errors", "negative", + "name: cf\nurl: https://x/y\nparser: nope_parser\n", true}, + {"negative_unknown_field", "negative: an unknown YAML key is rejected (KnownFields)", "negative", + "name: cf\nurl: https://x/y\nparser: text_cidr\ntypo_field: 1\n", true}, + {"boundary_minimal", "boundary: only the three required fields is enough", "boundary", + "name: m\nurl: https://x\nparser: csv\n", false}, + {"corner_bad_discover", "corner: an unknown discover mode errors", "corner", + "name: m\nurl: https://x\nparser: csv\ndiscover: teleport\n", true}, + } + dir := t.TempDir() + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + p := writeFile(t, dir, tc.name+".yaml", tc.body) + _, err := LoadFile(p) + if tc.wantErr && err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + if !tc.wantErr && err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + }) + } +} + +func TestLoadDir(t *testing.T) { + t.Run("positive_enabled_only_sorted", func(t *testing.T) { + dir := t.TempDir() + writeFile(t, dir, "b.yaml", "name: bbb\nurl: https://x\nparser: text_cidr\n") + writeFile(t, dir, "a.yaml", "name: aaa\nurl: https://x\nparser: text_cidr\n") + writeFile(t, dir, "off.yaml", "name: ccc\nurl: https://x\nparser: text_cidr\nenabled: false\n") + got, err := LoadDir(dir) + if err != nil { + t.Fatal(err) + } + if len(got) != 2 { + t.Fatalf("got %d sources, want 2 (disabled excluded)", len(got)) + } + if got[0].Name != "aaa" || got[1].Name != "bbb" { + t.Errorf("not sorted by name: %q, %q", got[0].Name, got[1].Name) + } + }) + + t.Run("negative_duplicate_name", func(t *testing.T) { + dir := t.TempDir() + writeFile(t, dir, "one.yaml", "name: dup\nurl: https://x\nparser: csv\n") + writeFile(t, dir, "two.yaml", "name: dup\nurl: https://y\nparser: csv\n") + if _, err := LoadDir(dir); err == nil { + t.Fatal("expected duplicate-name error, got nil") + } + }) + + t.Run("boundary_empty_dir", func(t *testing.T) { + got, err := LoadDir(t.TempDir()) + if err != nil { + t.Fatal(err) + } + if len(got) != 0 { + t.Fatalf("got %d, want 0", len(got)) + } + }) +} diff --git a/internal/ipfeed/fetch/discover.go b/internal/ipfeed/fetch/discover.go new file mode 100644 index 0000000..03721c5 --- /dev/null +++ b/internal/ipfeed/fetch/discover.go @@ -0,0 +1,33 @@ +package fetch + +import ( + "context" + "fmt" + "regexp" +) + +// azureJSONRe matches the current dated Service Tags JSON link on the Azure +// download page. Microsoft publishes the file weekly with a date in the name, +// so the URL must be discovered rather than hard-coded. +var azureJSONRe = regexp.MustCompile(`https://download\.microsoft\.com/download/[^"']*ServiceTags_Public_\d+\.json`) + +// Discover resolves a possibly-dynamic feed URL to the concrete URL to fetch. +// mode "" or "none" returns pageURL unchanged. "azure_download_page" fetches +// the download page and extracts the current dated JSON link. +func (c *Client) Discover(ctx context.Context, mode, pageURL string) (string, error) { + switch mode { + case "", "none": + return pageURL, nil + case "azure_download_page": + res, err := c.Get(ctx, pageURL, Conditional{}) + if err != nil { + return "", err + } + if m := azureJSONRe.Find(res.Body); m != nil { + return string(m), nil + } + return "", fmt.Errorf("azure discovery: no ServiceTags JSON link found on %s", pageURL) + default: + return "", fmt.Errorf("unknown discover mode %q", mode) + } +} diff --git a/internal/ipfeed/fetch/discover_test.go b/internal/ipfeed/fetch/discover_test.go new file mode 100644 index 0000000..47f1f96 --- /dev/null +++ b/internal/ipfeed/fetch/discover_test.go @@ -0,0 +1,64 @@ +package fetch + +import ( + "context" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestDiscover(t *testing.T) { + // A page containing a dated Azure ServiceTags link. + page := `dl` + pageSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte(page)) + })) + defer pageSrv.Close() + emptySrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte("no link here")) + })) + defer emptySrv.Close() + + c := NewClient(Options{MaxAttempts: 1, Jitter: func(time.Duration) time.Duration { return 0 }, + Sleep: func(context.Context, time.Duration) bool { return true }}) + + tests := []struct { + name string + desc string + class string + mode string + url string + want string + wantErr bool + }{ + {"positive_azure", "positive: extracts the dated JSON link from the download page", "positive", + "azure_download_page", pageSrv.URL, + "https://download.microsoft.com/download/a/b/ServiceTags_Public_20260907.json", false}, + {"boundary_none", "boundary: mode none returns the URL unchanged", "boundary", + "none", "https://example/x.json", "https://example/x.json", false}, + {"boundary_empty_mode", "boundary: empty mode returns the URL unchanged", "boundary", + "", "https://example/y.json", "https://example/y.json", false}, + {"negative_no_link", "negative: a page with no matching link errors", "negative", + "azure_download_page", emptySrv.URL, "", true}, + {"corner_unknown_mode", "corner: an unknown discover mode errors", "corner", + "bogus", pageSrv.URL, "", true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := c.Discover(context.Background(), tc.mode, tc.url) + if tc.wantErr { + if err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + return + } + if err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + if got != tc.want { + t.Errorf("%s: got %q, want %q", tc.desc, got, tc.want) + } + }) + } +} diff --git a/internal/ipfeed/fetch/fetch.go b/internal/ipfeed/fetch/fetch.go new file mode 100644 index 0000000..af52c99 --- /dev/null +++ b/internal/ipfeed/fetch/fetch.go @@ -0,0 +1,209 @@ +// Package fetch downloads feed bodies over HTTP with retries and full-jitter +// exponential backoff. The jitter and sleep are injectable so tests are +// deterministic and never actually sleep. It mirrors the backoff discipline +// used elsewhere in xtcp2 (crypto/rand full-jitter, context-aware sleep). +package fetch + +import ( + "context" + crand "crypto/rand" + "errors" + "fmt" + "io" + "math/big" + "net/http" + "time" +) + +// Result is the outcome of a successful (or not-modified) fetch. +type Result struct { + URL string + Status int + Body []byte + NotModified bool // server returned 304 for a conditional request + Attempts int + ETag string + LastModified string +} + +// Options configures a Client. Zero values are replaced with sensible defaults +// by NewClient, and the Jitter/Sleep seams default to crypto/rand + real time. +type Options struct { + MaxAttempts int // total attempts (>=1); default 10 + BackoffBase time.Duration // base window; default 1s + BackoffCap time.Duration // max window; default 1h + Timeout time.Duration // per-request timeout; default 30s + UserAgent string + + // Jitter returns a duration uniformly in [0, max). Injectable for tests. + Jitter func(max time.Duration) time.Duration + // Sleep waits d or until ctx is done; returns true if it slept fully. + Sleep func(ctx context.Context, d time.Duration) bool +} + +// Client performs retrying HTTP GETs. It reuses one http.Client for keep-alive. +type Client struct { + hc *http.Client + opts Options +} + +// NewClient builds a Client, applying defaults to any zero Options fields. +func NewClient(opts Options) *Client { + if opts.MaxAttempts < 1 { + opts.MaxAttempts = 10 + } + if opts.BackoffBase <= 0 { + opts.BackoffBase = time.Second + } + if opts.BackoffCap <= 0 { + opts.BackoffCap = time.Hour + } + if opts.Timeout <= 0 { + opts.Timeout = 30 * time.Second + } + if opts.UserAgent == "" { + opts.UserAgent = "ipfeed-collector/1" + } + if opts.Jitter == nil { + opts.Jitter = cryptoJitter + } + if opts.Sleep == nil { + opts.Sleep = SleepCtx + } + return &Client{ + hc: &http.Client{Timeout: opts.Timeout}, + opts: opts, + } +} + +// Conditional carries optional cache validators for a conditional request. +type Conditional struct { + ETag string + LastModified string +} + +// Get fetches url with retries. A 2xx returns the body; a 304 (only possible +// when cond is set) returns NotModified. Non-retryable 4xx (other than 429) +// fail immediately; 5xx, 429, and transport errors are retried with backoff. +func (c *Client) Get(ctx context.Context, url string, cond Conditional) (Result, error) { + var lastErr error + var lastRes Result + for attempt := 1; attempt <= c.opts.MaxAttempts; attempt++ { + res, retryable, err := c.attempt(ctx, url, cond) + res.Attempts = attempt + lastRes = res + if err == nil { + return res, nil + } + lastErr = err + if !retryable || attempt == c.opts.MaxAttempts { + break + } + // Full-jitter: window grows exponentially, clamped to cap; the actual + // wait is drawn uniformly in [0, window]. + window := c.backoffWindow(attempt) + if !c.opts.Sleep(ctx, c.opts.Jitter(window)) { + return lastRes, ctx.Err() + } + } + return lastRes, fmt.Errorf("fetch %s: %w", url, lastErr) +} + +// backoffWindow returns base<<(attempt-1) clamped to cap, guarding overflow. +func (c *Client) backoffWindow(attempt int) time.Duration { + w := c.opts.BackoffBase + for i := 1; i < attempt; i++ { + w <<= 1 + if w <= 0 || w >= c.opts.BackoffCap { + return c.opts.BackoffCap + } + } + if w > c.opts.BackoffCap { + w = c.opts.BackoffCap + } + return w +} + +// attempt performs a single request. The bool reports whether a failure is +// worth retrying. +func (c *Client) attempt(ctx context.Context, url string, cond Conditional) (Result, bool, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) + if err != nil { + return Result{URL: url}, false, err // malformed URL: not retryable + } + req.Header.Set("User-Agent", c.opts.UserAgent) + if cond.ETag != "" { + req.Header.Set("If-None-Match", cond.ETag) + } + if cond.LastModified != "" { + req.Header.Set("If-Modified-Since", cond.LastModified) + } + + resp, err := c.hc.Do(req) + if err != nil { + // Context cancellation is terminal; transport errors are retryable. + if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + return Result{URL: url}, false, err + } + return Result{URL: url}, true, err + } + defer resp.Body.Close() + + res := Result{ + URL: url, + Status: resp.StatusCode, + ETag: resp.Header.Get("ETag"), + LastModified: resp.Header.Get("Last-Modified"), + } + + switch { + case resp.StatusCode == http.StatusNotModified: + // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused + io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse + res.NotModified = true + return res, false, nil + case resp.StatusCode >= 200 && resp.StatusCode < 300: + body, err := io.ReadAll(resp.Body) + if err != nil { + return res, true, err // truncated read: retry + } + res.Body = body + return res, false, nil + case resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500: + // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused + io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse + return res, true, fmt.Errorf("http status %d", resp.StatusCode) + default: + // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused + io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse + return res, false, fmt.Errorf("http status %d", resp.StatusCode) + } +} + +// cryptoJitter returns a uniform duration in [0, limit) using crypto/rand. +func cryptoJitter(limit time.Duration) time.Duration { + if limit <= 0 { + return 0 + } + n, err := crand.Int(crand.Reader, big.NewInt(int64(limit))) + if err != nil { + return limit / 2 // extremely unlikely; degrade to a fixed mid wait + } + return time.Duration(n.Int64()) +} + +// SleepCtx sleeps for d or until ctx is done. It returns true if the full +// duration elapsed, false if ctx was canceled first. +func SleepCtx(ctx context.Context, d time.Duration) bool { + if d <= 0 { + return ctx.Err() == nil + } + t := time.NewTimer(d) + defer t.Stop() + select { + case <-t.C: + return true + case <-ctx.Done(): + return false + } +} diff --git a/internal/ipfeed/fetch/fetch_race_test.go b/internal/ipfeed/fetch/fetch_race_test.go new file mode 100644 index 0000000..d1cc587 --- /dev/null +++ b/internal/ipfeed/fetch/fetch_race_test.go @@ -0,0 +1,50 @@ +package fetch + +import ( + "context" + "net/http" + "net/http/httptest" + "strconv" + "sync" + "testing" +) + +// TestClientGetConcurrent shares one *Client across many goroutines hitting a +// single server, so `go test -race` verifies the reused http.Client and the +// retry/backoff seams carry no data race. Each goroutine uses a distinct URL +// key; the server fails that key's first request (500) then serves 200, so +// every goroutine deterministically exercises exactly one retry — the backoff +// window/jitter/sleep seams run concurrently, not just the happy path. +func TestClientGetConcurrent(t *testing.T) { + var seen sync.Map // key -> struct{}: has this key been hit before? + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + key := r.URL.RawQuery + if _, hit := seen.LoadOrStore(key, struct{}{}); !hit { + w.WriteHeader(http.StatusInternalServerError) // first hit for this key + return + } + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("ok")) + })) + defer srv.Close() + + client := testClient(5, nil) // no-op sleep, zero jitter -> deterministic, fast + + const goroutines = 50 + var wg sync.WaitGroup + errs := make([]error, goroutines) + for i := range goroutines { + wg.Go(func() { + url := srv.URL + "?g=" + strconv.Itoa(i) + _, err := client.Get(context.Background(), url, Conditional{}) + errs[i] = err + }) + } + wg.Wait() + + for i, err := range errs { + if err != nil { + t.Errorf("goroutine %d: unexpected error: %v", i, err) + } + } +} diff --git a/internal/ipfeed/fetch/fetch_test.go b/internal/ipfeed/fetch/fetch_test.go new file mode 100644 index 0000000..4296ecf --- /dev/null +++ b/internal/ipfeed/fetch/fetch_test.go @@ -0,0 +1,128 @@ +package fetch + +import ( + "context" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +// newSeqServer returns a server that replies with the given status codes in +// order (repeating the last one after the slice is exhausted), writing the +// body "ok" for any 2xx. +func newSeqServer(statuses ...int) (*httptest.Server, *int) { + calls := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + st := statuses[min(calls, len(statuses)-1)] + calls++ + w.WriteHeader(st) + if st >= 200 && st < 300 { + _, _ = w.Write([]byte("ok")) + } + })) + return srv, &calls +} + +// testClient builds a Client with deterministic (no-op) jitter/sleep seams so +// retries are exercised without real waiting. +func testClient(maxAttempts int, sleep func(context.Context, time.Duration) bool) *Client { + if sleep == nil { + sleep = func(context.Context, time.Duration) bool { return true } + } + return NewClient(Options{ + MaxAttempts: maxAttempts, + Jitter: func(time.Duration) time.Duration { return 0 }, + Sleep: sleep, + }) +} + +func TestGet(t *testing.T) { + tests := []struct { + name string + desc string + class string + statuses []int + maxAttempts int + wantErr bool + wantAttempts int + wantBody string + }{ + {"positive_ok", "positive: a 200 on the first try returns the body", "positive", + []int{200}, 3, false, 1, "ok"}, + {"corner_500_then_200", "corner: a 500 is retried and the following 200 succeeds", "corner", + []int{500, 200}, 3, false, 2, "ok"}, + {"corner_429_then_200", "corner: 429 Too Many Requests is retryable", "corner", + []int{429, 200}, 3, false, 2, "ok"}, + {"negative_always_500", "negative: persistent 5xx fails after exhausting attempts", "negative", + []int{500}, 3, true, 3, ""}, + {"boundary_404_no_retry", "boundary: a non-retryable 404 fails immediately on attempt 1", "boundary", + []int{404}, 3, true, 1, ""}, + {"boundary_single_attempt", "boundary: max-attempts=1 makes one attempt only", "boundary", + []int{500}, 1, true, 1, ""}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + srv, calls := newSeqServer(tc.statuses...) + defer srv.Close() + c := testClient(tc.maxAttempts, nil) + + res, err := c.Get(context.Background(), srv.URL, Conditional{}) + if tc.wantErr && err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + if !tc.wantErr && err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + if res.Attempts != tc.wantAttempts { + t.Errorf("%s: attempts = %d, want %d", tc.desc, res.Attempts, tc.wantAttempts) + } + if *calls != tc.wantAttempts { + t.Errorf("%s: server calls = %d, want %d", tc.desc, *calls, tc.wantAttempts) + } + if !tc.wantErr && string(res.Body) != tc.wantBody { + t.Errorf("%s: body = %q, want %q", tc.desc, res.Body, tc.wantBody) + } + }) + } +} + +// TestGetContextCancelDuringBackoff verifies that a canceled context during +// the backoff wait aborts with the context error rather than retrying. +func TestGetContextCancelDuringBackoff(t *testing.T) { + srv, _ := newSeqServer(500) + defer srv.Close() + ctx, cancel := context.WithCancel(context.Background()) + // Sleep seam cancels the context and reports "did not complete". + c := testClient(5, func(context.Context, time.Duration) bool { + cancel() + return false + }) + _, err := c.Get(ctx, srv.URL, Conditional{}) + if err != context.Canceled { + t.Fatalf("want context.Canceled, got %v", err) + } +} + +func TestBackoffWindow(t *testing.T) { + c := NewClient(Options{BackoffBase: time.Second, BackoffCap: 8 * time.Second}) + tests := []struct { + name string + desc string + class string + attempt int + want time.Duration + }{ + {"positive_first", "positive: attempt 1 window equals base", "positive", 1, time.Second}, + {"positive_grow", "positive: attempt 3 window is base<<2", "positive", 3, 4 * time.Second}, + {"boundary_at_cap", "boundary: attempt 4 window is exactly the cap", "boundary", 4, 8 * time.Second}, + {"corner_beyond_cap", "corner: a large attempt is clamped to the cap", "corner", 20, 8 * time.Second}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := c.backoffWindow(tc.attempt); got != tc.want { + t.Errorf("%s: backoffWindow(%d) = %v, want %v", tc.desc, tc.attempt, got, tc.want) + } + }) + } +} diff --git a/internal/ipfeed/health/health.go b/internal/ipfeed/health/health.go new file mode 100644 index 0000000..5fb40de --- /dev/null +++ b/internal/ipfeed/health/health.go @@ -0,0 +1,91 @@ +// Package health serves liveness and readiness endpoints for daemon mode. +// /healthz reports process liveness (always 200 once serving); /readyz reports +// 200 only after at least one successful collection cycle, so orchestrators +// can wait for the first dataset before routing/alerting. +package health + +import ( + "context" + "errors" + "log/slog" + "net" + "net/http" + "sync/atomic" + "time" +) + +// Server wraps an http.Server plus a readiness flag. +type Server struct { + ready atomic.Bool + http *http.Server +} + +// NewServer builds a health server bound to addr (e.g. ":8080"). It does not +// start listening until Start is called. +func NewServer(addr string) *Server { + s := &Server{} + mux := http.NewServeMux() + mux.HandleFunc("/healthz", s.handleHealthz) + mux.HandleFunc("/readyz", s.handleReadyz) + s.http = &http.Server{ + Addr: addr, + Handler: mux, + ReadHeaderTimeout: 5 * time.Second, + } + return s +} + +// SetReady marks the service ready (idempotent). Called after a successful cycle. +func (s *Server) SetReady() { s.ready.Store(true) } + +// Ready reports the current readiness state. +func (s *Server) Ready() bool { return s.ready.Load() } + +// writeBody writes the response body. A write error means the client +// disconnected before reading the response — nothing the handler can do — so it +// is checked here once and dropped rather than ignored blank at each call site. +func writeBody(w http.ResponseWriter, s string) { + if _, err := w.Write([]byte(s)); err != nil { + return + } +} + +func (s *Server) handleHealthz(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + writeBody(w, "ok") +} + +func (s *Server) handleReadyz(w http.ResponseWriter, _ *http.Request) { + if s.ready.Load() { + w.WriteHeader(http.StatusOK) + writeBody(w, "ready") + return + } + w.WriteHeader(http.StatusServiceUnavailable) + writeBody(w, "not ready") +} + +// Start begins serving in a background goroutine. It returns once the listener +// is bound (so a bind error surfaces synchronously) or an error if binding +// failed. A non-graceful Serve error is logged (the daemon keeps running; a +// dead health endpoint must not take down collection). +func (s *Server) Start(ctx context.Context) error { + ln, err := (&net.ListenConfig{}).Listen(ctx, "tcp", s.http.Addr) + if err != nil { + return err + } + go func() { + if serr := s.http.Serve(ln); serr != nil && !errors.Is(serr, http.ErrServerClosed) { + slog.Error("health server stopped", "err", serr) + } + }() + return nil +} + +// Shutdown gracefully stops the server. +func (s *Server) Shutdown(ctx context.Context) error { + return s.http.Shutdown(ctx) +} + +// Handler exposes the mux for testing without binding a socket. +func (s *Server) Handler() http.Handler { return s.http.Handler } diff --git a/internal/ipfeed/health/health_race_test.go b/internal/ipfeed/health/health_race_test.go new file mode 100644 index 0000000..c714aea --- /dev/null +++ b/internal/ipfeed/health/health_race_test.go @@ -0,0 +1,47 @@ +package health + +import ( + "net/http" + "net/http/httptest" + "sync" + "testing" +) + +// TestReadinessConcurrent drives SetReady() from many goroutines while others +// serve /readyz, so `go test -race` verifies the readiness atomic.Bool has no +// data race between writers and readers. After all goroutines finish, readiness +// must be latched true (SetReady is monotonic/idempotent). +func TestReadinessConcurrent(t *testing.T) { + s := NewServer(":0") + h := s.Handler() + + const writers, readers = 16, 16 + var wg sync.WaitGroup + + for range writers { + wg.Go(func() { + for range 100 { + s.SetReady() + } + }) + } + for range readers { + wg.Go(func() { + for range 100 { + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, "/readyz", nil) + h.ServeHTTP(rec, req) + // Status races with the writers (200 or 503), so we only assert + // it is one of the two valid outcomes — never a panic or 0. + if rec.Code != http.StatusOK && rec.Code != http.StatusServiceUnavailable { + t.Errorf("unexpected /readyz status %d", rec.Code) + } + } + }) + } + wg.Wait() + + if !s.Ready() { + t.Fatal("readiness should be latched true after concurrent SetReady") + } +} diff --git a/internal/ipfeed/health/health_test.go b/internal/ipfeed/health/health_test.go new file mode 100644 index 0000000..0e8dfe4 --- /dev/null +++ b/internal/ipfeed/health/health_test.go @@ -0,0 +1,53 @@ +package health + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func TestReadyzHealthz(t *testing.T) { + tests := []struct { + name string + desc string + class string + path string + setReady bool + wantStatus int + }{ + {"positive_healthz", "positive: healthz is 200 regardless of readiness", "positive", + "/healthz", false, http.StatusOK}, + {"negative_readyz_before", "negative: readyz is 503 before any successful cycle", "negative", + "/readyz", false, http.StatusServiceUnavailable}, + {"boundary_readyz_after", "boundary: readyz flips to 200 right after SetReady", "boundary", + "/readyz", true, http.StatusOK}, + {"corner_unknown_path", "corner: an unregistered path 404s", "corner", + "/nope", true, http.StatusNotFound}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + s := NewServer(":0") + if tc.setReady { + s.SetReady() + } + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, tc.path, nil) + s.Handler().ServeHTTP(rec, req) + if rec.Code != tc.wantStatus { + t.Errorf("%s: status = %d, want %d", tc.desc, rec.Code, tc.wantStatus) + } + }) + } +} + +func TestSetReadyIdempotent(t *testing.T) { + s := NewServer(":0") + if s.Ready() { + t.Fatal("should start not-ready") + } + s.SetReady() + s.SetReady() // idempotent + if !s.Ready() { + t.Fatal("should be ready after SetReady") + } +} diff --git a/internal/ipfeed/model/record.go b/internal/ipfeed/model/record.go new file mode 100644 index 0000000..818a85c --- /dev/null +++ b/internal/ipfeed/model/record.go @@ -0,0 +1,37 @@ +// Package model defines the normalized record produced by ipfeed-collector. +// +// The schema follows the recommended normalized schema from the source +// catalog: an address can carry several independent classifications +// (network ownership vs service operator vs specific service), so overlapping +// records are retained rather than collapsed to one provider per prefix. +package model + +// Record is one normalized IP-range classification row. +// +// Struct tags are used both for JSON (debug/NDJSON dumps) and for the Parquet +// writer. Every field is a string (or small int) so the schema stays flat and +// easy to query with DuckDB / parquet tooling. Empty strings mean "not +// provided by this feed" — we do not invent values. +type Record struct { + Prefix string `json:"prefix" parquet:"prefix"` + IPVersion int32 `json:"ip_version" parquet:"ip_version"` + // ASN is the representative BGP autonomous-system number for this prefix, + // derived from NetworkOwner via a curated map (internal/ipfeed/asnmap). It is + // 0 when the owner has no known ASN. This is a per-provider *representative* + // ASN, not a per-prefix BGP-origin ASN — see the asnmap package docs. + ASN uint32 `json:"asn" parquet:"asn"` + NetworkOwner string `json:"network_owner" parquet:"network_owner"` + ServiceOperator string `json:"service_operator" parquet:"service_operator"` + Provider string `json:"provider" parquet:"provider"` + Service string `json:"service" parquet:"service"` + Product string `json:"product" parquet:"product"` + Region string `json:"region" parquet:"region"` + NetworkBorderGroup string `json:"network_border_group" parquet:"network_border_group"` + Direction string `json:"direction" parquet:"direction"` + SourceName string `json:"source_name" parquet:"source_name"` + SourceType string `json:"source_type" parquet:"source_type"` + SourceURL string `json:"source_url" parquet:"source_url"` + SourceTimestamp string `json:"source_timestamp" parquet:"source_timestamp"` + RetrievedAt string `json:"retrieved_at" parquet:"retrieved_at"` + Confidence string `json:"confidence" parquet:"confidence"` +} diff --git a/internal/ipfeed/output/parquet.go b/internal/ipfeed/output/parquet.go new file mode 100644 index 0000000..f87dd7c --- /dev/null +++ b/internal/ipfeed/output/parquet.go @@ -0,0 +1,47 @@ +// Package output writes the combined dataset to a timestamped Parquet file. +package output + +import ( + "fmt" + "os" + "time" + + "github.com/parquet-go/parquet-go" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// Timestamp formats t as the YYYY-MM-DD-HH-MM basename (UTC), matching the +// required S3 object naming. +func Timestamp(t time.Time) string { return t.UTC().Format("2006-01-02-15-04") } + +// Filename returns the Parquet filename for time t, e.g. 2026-09-09-14-30.parquet. +func Filename(t time.Time) string { return Timestamp(t) + ".parquet" } + +// WriteParquet writes records to path and returns the file size in bytes. +func WriteParquet(path string, records []model.Record) (int64, error) { + f, err := os.Create(path) + if err != nil { + return 0, err + } + w := parquet.NewGenericWriter[model.Record](f) + if len(records) > 0 { + if _, err := w.Write(records); err != nil { + _ = f.Close() // error path: best-effort close, surfacing the write error + return 0, fmt.Errorf("write parquet rows: %w", err) + } + } + if err := w.Close(); err != nil { + _ = f.Close() // error path: best-effort close, surfacing the writer error + return 0, fmt.Errorf("close parquet writer: %w", err) + } + fi, err := f.Stat() + if err != nil { + _ = f.Close() // error path: best-effort close, surfacing the stat error + return 0, err + } + size := fi.Size() + if err := f.Close(); err != nil { + return 0, err + } + return size, nil +} diff --git a/internal/ipfeed/output/parquet_bench_test.go b/internal/ipfeed/output/parquet_bench_test.go new file mode 100644 index 0000000..e576bd5 --- /dev/null +++ b/internal/ipfeed/output/parquet_bench_test.go @@ -0,0 +1,55 @@ +package output + +import ( + "fmt" + "path/filepath" + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// genRecords builds n fully-populated records so the Parquet writer exercises +// every column, not just the sparse ones. +func genRecords(n int) []model.Record { + recs := make([]model.Record, n) + for i := range n { + recs[i] = model.Record{ + Prefix: fmt.Sprintf("10.%d.%d.0/24", (i>>8)&0xff, i&0xff), + IPVersion: 4, + NetworkOwner: "bench", + ServiceOperator: "bench", + Provider: "bench", + Service: "svc", + Region: "us-east-1", + SourceName: "bench", + SourceType: "provider_feed", + SourceURL: "https://example/feed.json", + RetrievedAt: "2026-01-01T00:00:00Z", + Confidence: "authoritative", + } + } + return recs +} + +// BenchmarkWriteParquet measures Parquet write throughput and allocations +// across dataset sizes. It writes to a temp file per run (WriteParquet takes a +// path); SetBytes reports the encoded size so `-benchmem` shows MB/s. +func BenchmarkWriteParquet(b *testing.B) { + for _, size := range []int{1_000, 100_000} { + recs := genRecords(size) + b.Run(fmt.Sprintf("n=%d", size), func(b *testing.B) { + b.ReportAllocs() + b.ResetTimer() + var written int64 + for i := range b.N { + path := filepath.Join(b.TempDir(), fmt.Sprintf("bench-%d.parquet", i)) + n, err := WriteParquet(path, recs) + if err != nil { + b.Fatalf("WriteParquet: %v", err) + } + written = n + } + b.SetBytes(written) + }) + } +} diff --git a/internal/ipfeed/output/parquet_test.go b/internal/ipfeed/output/parquet_test.go new file mode 100644 index 0000000..17c0e40 --- /dev/null +++ b/internal/ipfeed/output/parquet_test.go @@ -0,0 +1,74 @@ +package output + +import ( + "os" + "path/filepath" + "testing" + "time" + + "github.com/parquet-go/parquet-go" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func TestTimestampAndFilename(t *testing.T) { + tm := time.Date(2026, 9, 9, 14, 30, 5, 0, time.UTC) + tests := []struct { + name string + desc string + got string + want string + }{ + {"positive_timestamp", "positive: minute-granularity UTC stamp, seconds dropped", + Timestamp(tm), "2026-09-09-14-30"}, + {"positive_filename", "positive: filename appends .parquet", + Filename(tm), "2026-09-09-14-30.parquet"}, + {"boundary_utc_conversion", "boundary: a non-UTC time is converted to UTC before formatting", + Timestamp(tm.In(time.FixedZone("x", 3600))), "2026-09-09-14-30"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if tc.got != tc.want { + t.Errorf("%s: got %q, want %q", tc.desc, tc.got, tc.want) + } + }) + } +} + +func TestWriteParquet(t *testing.T) { + tests := []struct { + name string + desc string + class string + records []model.Record + }{ + {"positive_rows", "positive: writes rows and reports a positive size", "positive", + []model.Record{{Prefix: "1.2.3.0/24", IPVersion: 4}, {Prefix: "2600::/16", IPVersion: 6}}}, + {"boundary_empty", "boundary: zero records still produces a valid parquet file", "boundary", + nil}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + path := filepath.Join(t.TempDir(), "out.parquet") + size, err := WriteParquet(path, tc.records) + if err != nil { + t.Fatalf("%s: %v", tc.desc, err) + } + if size <= 0 { + t.Fatalf("%s: size = %d, want > 0", tc.desc, size) + } + f, err := os.Open(path) + if err != nil { + t.Fatal(err) + } + defer f.Close() + st, _ := f.Stat() + pf, err := parquet.OpenFile(f, st.Size()) + if err != nil { + t.Fatalf("%s: reopen: %v", tc.desc, err) + } + if got := pf.NumRows(); got != int64(len(tc.records)) { + t.Errorf("%s: NumRows = %d, want %d", tc.desc, got, len(tc.records)) + } + }) + } +} diff --git a/internal/ipfeed/parse/csv.go b/internal/ipfeed/parse/csv.go new file mode 100644 index 0000000..f089cac --- /dev/null +++ b/internal/ipfeed/parse/csv.go @@ -0,0 +1,72 @@ +package parse + +import ( + "bytes" + "encoding/csv" + "fmt" + "io" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("csv", csvParser{}) } + +// csvParser handles column-oriented CSV feeds (DigitalOcean google.csv, Apple +// egress-ip-ranges.csv, the AWS geo-ip-feed.csv). Column positions are given +// in parser_opts: +// +// prefix_column: 0 # 0-based column holding the CIDR (required, default 0) +// region_column: -1 # optional region column; -1 disables +// service_column: -1 # optional service column; -1 disables +// has_header: false # skip the first row if true +// comment: "" # optional single-char comment prefix +// +// Rows with too few columns for prefix_column are skipped (they produce no +// record and are simply not counted as valid). +type csvParser struct{} + +func (csvParser) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + o := opts(meta.Opts) + prefixCol := o.int("prefix_column", 0) + regionCol := o.int("region_column", -1) + serviceCol := o.int("service_column", -1) + hasHeader := o.boolean("has_header", false) + + data = bytes.TrimPrefix(data, utf8BOM) + r := csv.NewReader(bytes.NewReader(data)) + r.FieldsPerRecord = -1 // tolerate ragged rows + r.TrimLeadingSpace = true + if c := o.str("comment", ""); c != "" { + r.Comment = rune(c[0]) + } + + var out []model.Record + first := true + for { + row, err := r.Read() + if err == io.EOF { + break + } + if err != nil { + return nil, fmt.Errorf("csv: %w", err) + } + if first && hasHeader { + first = false + continue + } + first = false + if prefixCol < 0 || prefixCol >= len(row) { + continue + } + rec := meta.Base(retrievedAt) + rec.Prefix = row[prefixCol] + if regionCol >= 0 && regionCol < len(row) { + rec.Region = row[regionCol] + } + if serviceCol >= 0 && serviceCol < len(row) { + rec.Service = row[serviceCol] + } + out = append(out, rec) + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_atlassian.go b/internal/ipfeed/parse/json_atlassian.go new file mode 100644 index 0000000..075e559 --- /dev/null +++ b/internal/ipfeed/parse/json_atlassian.go @@ -0,0 +1,43 @@ +package parse + +import ( + "encoding/json" + "fmt" + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("atlassian", atlassianFeed{}) } + +// atlassianFeed parses https://ip-ranges.atlassian.com/, whose items each +// carry a cidr plus arrays of product, region, and direction metadata. +type atlassianFeed struct{} + +type atlassianDoc struct { + CreationDate string `json:"creationDate"` + Items []struct { + CIDR string `json:"cidr"` + Region []string `json:"region"` + Product []string `json:"product"` + Direction []string `json:"direction"` + } `json:"items"` +} + +func (atlassianFeed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d atlassianDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("atlassian: %w", err) + } + out := make([]model.Record, 0, len(d.Items)) + for _, it := range d.Items { + r := meta.Base(retrievedAt) + r.Prefix = it.CIDR + r.Product = strings.Join(it.Product, ",") + r.Region = strings.Join(it.Region, ",") + r.Direction = strings.Join(it.Direction, ",") + r.SourceTimestamp = d.CreationDate + out = append(out, r) + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_aws.go b/internal/ipfeed/parse/json_aws.go new file mode 100644 index 0000000..f531934 --- /dev/null +++ b/internal/ipfeed/parse/json_aws.go @@ -0,0 +1,58 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("aws_ip_ranges", awsIPRanges{}) } + +// awsIPRanges parses https://ip-ranges.amazonaws.com/ip-ranges.json. It keeps +// the service, region, and network_border_group metadata AWS publishes; the +// createDate becomes the record source_timestamp. +type awsIPRanges struct{} + +type awsFeed struct { + CreateDate string `json:"createDate"` + Prefixes []struct { + IPPrefix string `json:"ip_prefix"` + Region string `json:"region"` + Service string `json:"service"` + NetworkBorderGroup string `json:"network_border_group"` + } `json:"prefixes"` + IPv6Prefixes []struct { + IPv6Prefix string `json:"ipv6_prefix"` + Region string `json:"region"` + Service string `json:"service"` + NetworkBorderGroup string `json:"network_border_group"` + } `json:"ipv6_prefixes"` +} + +func (awsIPRanges) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var f awsFeed + if err := json.Unmarshal(data, &f); err != nil { + return nil, fmt.Errorf("aws_ip_ranges: %w", err) + } + out := make([]model.Record, 0, len(f.Prefixes)+len(f.IPv6Prefixes)) + for _, p := range f.Prefixes { + r := meta.Base(retrievedAt) + r.Prefix = p.IPPrefix + r.Region = p.Region + r.Service = p.Service + r.NetworkBorderGroup = p.NetworkBorderGroup + r.SourceTimestamp = f.CreateDate + out = append(out, r) + } + for _, p := range f.IPv6Prefixes { + r := meta.Base(retrievedAt) + r.Prefix = p.IPv6Prefix + r.Region = p.Region + r.Service = p.Service + r.NetworkBorderGroup = p.NetworkBorderGroup + r.SourceTimestamp = f.CreateDate + out = append(out, r) + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_azure.go b/internal/ipfeed/parse/json_azure.go new file mode 100644 index 0000000..06e1608 --- /dev/null +++ b/internal/ipfeed/parse/json_azure.go @@ -0,0 +1,50 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("azure_service_tags", azureServiceTags{}) } + +// azureServiceTags parses the Azure Service Tags JSON (discovered from the +// download page). Each value carries a systemService, region, and an +// addressPrefixes array covering both IPv4 and IPv6. +type azureServiceTags struct{} + +type azureDoc struct { + ChangeNumber int `json:"changeNumber"` + Cloud string `json:"cloud"` + Values []struct { + Name string `json:"name"` + Properties struct { + Region string `json:"region"` + SystemService string `json:"systemService"` + AddressPrefixes []string `json:"addressPrefixes"` + } `json:"properties"` + } `json:"values"` +} + +func (azureServiceTags) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d azureDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("azure_service_tags: %w", err) + } + var out []model.Record + for _, v := range d.Values { + service := v.Properties.SystemService + if service == "" { + service = v.Name + } + for _, c := range v.Properties.AddressPrefixes { + r := meta.Base(retrievedAt) + r.Prefix = c + r.Service = service + r.Region = v.Properties.Region + out = append(out, r) + } + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_fastly.go b/internal/ipfeed/parse/json_fastly.go new file mode 100644 index 0000000..69e4660 --- /dev/null +++ b/internal/ipfeed/parse/json_fastly.go @@ -0,0 +1,33 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("fastly", fastlyFeed{}) } + +// fastlyFeed parses https://api.fastly.com/public-ip-list, which returns two +// flat arrays of CIDRs. +type fastlyFeed struct{} + +type fastlyDoc struct { + Addresses []string `json:"addresses"` + IPv6Addresses []string `json:"ipv6_addresses"` +} + +func (fastlyFeed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d fastlyDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("fastly: %w", err) + } + out := make([]model.Record, 0, len(d.Addresses)+len(d.IPv6Addresses)) + for _, c := range append(append([]string{}, d.Addresses...), d.IPv6Addresses...) { + r := meta.Base(retrievedAt) + r.Prefix = c + out = append(out, r) + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_github.go b/internal/ipfeed/parse/json_github.go new file mode 100644 index 0000000..d4f8820 --- /dev/null +++ b/internal/ipfeed/parse/json_github.go @@ -0,0 +1,51 @@ +package parse + +import ( + "encoding/json" + "fmt" + "sort" + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("github_meta", githubMeta{}) } + +// githubMeta parses https://api.github.com/meta, an object whose values are +// per-service CIDR arrays (hooks, web, api, git, packages, pages, actions, +// actions_macos, dependabot, copilot, ...). Non-array values (booleans, the +// ssh key fingerprint object, domains, etc.) are ignored. The JSON key becomes +// the record service. +type githubMeta struct{} + +func (githubMeta) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var raw map[string]json.RawMessage + if err := json.Unmarshal(data, &raw); err != nil { + return nil, fmt.Errorf("github_meta: %w", err) + } + // Deterministic order for stable output/tests. + keys := make([]string, 0, len(raw)) + for k := range raw { + keys = append(keys, k) + } + sort.Strings(keys) + + var out []model.Record + for _, k := range keys { + var cidrs []string + if err := json.Unmarshal(raw[k], &cidrs); err != nil { + continue // value is not a []string (e.g. bool/object): skip + } + for _, c := range cidrs { + c = strings.TrimSpace(c) + if c == "" { + continue + } + r := meta.Base(retrievedAt) + r.Prefix = c + r.Service = k + out = append(out, r) + } + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_m365.go b/internal/ipfeed/parse/json_m365.go new file mode 100644 index 0000000..482ffa3 --- /dev/null +++ b/internal/ipfeed/parse/json_m365.go @@ -0,0 +1,39 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("m365", m365Feed{}) } + +// m365Feed parses the Microsoft 365 endpoints web service +// (endpoints.office.com/endpoints/worldwide), a top-level array of endpoint +// sets, each with a serviceArea, a category, and an ips array (CIDRs). +type m365Feed struct{} + +type m365Entry struct { + ServiceArea string `json:"serviceArea"` + Category string `json:"category"` + IPs []string `json:"ips"` +} + +func (m365Feed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var entries []m365Entry + if err := json.Unmarshal(data, &entries); err != nil { + return nil, fmt.Errorf("m365: %w", err) + } + var out []model.Record + for _, e := range entries { + for _, c := range e.IPs { + r := meta.Base(retrievedAt) + r.Prefix = c + r.Service = e.ServiceArea + r.Product = e.Category + out = append(out, r) + } + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_oci.go b/internal/ipfeed/parse/json_oci.go new file mode 100644 index 0000000..75770c2 --- /dev/null +++ b/internal/ipfeed/parse/json_oci.go @@ -0,0 +1,45 @@ +package parse + +import ( + "encoding/json" + "fmt" + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("oci", ociFeed{}) } + +// ociFeed parses https://docs.oracle.com/iaas/tools/public_ip_ranges.json, +// which groups CIDRs by region, each with a list of service tags. +type ociFeed struct{} + +type ociDoc struct { + LastUpdatedTimestamp string `json:"last_updated_timestamp"` + Regions []struct { + Region string `json:"region"` + CIDRs []struct { + CIDR string `json:"cidr"` + Tags []string `json:"tags"` + } `json:"cidrs"` + } `json:"regions"` +} + +func (ociFeed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d ociDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("oci: %w", err) + } + var out []model.Record + for _, reg := range d.Regions { + for _, c := range reg.CIDRs { + r := meta.Base(retrievedAt) + r.Prefix = c.CIDR + r.Region = reg.Region + r.Service = strings.Join(c.Tags, ",") + r.SourceTimestamp = d.LastUpdatedTimestamp + out = append(out, r) + } + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_prefixes.go b/internal/ipfeed/parse/json_prefixes.go new file mode 100644 index 0000000..c91dbe5 --- /dev/null +++ b/internal/ipfeed/parse/json_prefixes.go @@ -0,0 +1,59 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// The GCP, Applebot, and Google crawler feeds share a shape: a top-level +// "prefixes" array whose entries carry either "ipv4Prefix" or "ipv6Prefix", +// and (for GCP) optional "service"/"scope" metadata. One parser type serves +// all three, registered under three keys. +func init() { + Register("gcp_ipranges", prefixesFeed{}) + Register("applebot", prefixesFeed{}) + Register("google_crawlers", prefixesFeed{}) +} + +type prefixesFeed struct{} + +type prefixesDoc struct { + SyncToken string `json:"syncToken"` + CreationTime string `json:"creationTime"` + Prefixes []struct { + IPv4Prefix string `json:"ipv4Prefix"` + IPv6Prefix string `json:"ipv6Prefix"` + Service string `json:"service"` + Scope string `json:"scope"` + } `json:"prefixes"` +} + +func (prefixesFeed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d prefixesDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("prefixes feed: %w", err) + } + out := make([]model.Record, 0, len(d.Prefixes)) + for _, p := range d.Prefixes { + cidr := p.IPv4Prefix + if cidr == "" { + cidr = p.IPv6Prefix + } + if cidr == "" { + continue + } + r := meta.Base(retrievedAt) + r.Prefix = cidr + if p.Service != "" { + r.Service = p.Service + } + if p.Scope != "" { + r.Region = p.Scope + } + r.SourceTimestamp = d.CreationTime + out = append(out, r) + } + return out, nil +} diff --git a/internal/ipfeed/parse/json_salesforce.go b/internal/ipfeed/parse/json_salesforce.go new file mode 100644 index 0000000..f7c9f49 --- /dev/null +++ b/internal/ipfeed/parse/json_salesforce.go @@ -0,0 +1,54 @@ +package parse + +import ( + "encoding/json" + "fmt" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("salesforce", salesforceFeed{}) } + +// salesforceFeed parses https://ip-ranges.salesforce.com/ip-ranges.json +// (Hyperforce), an AWS-style document with ip_prefix / ipv6_prefix entries +// that additionally carry a direction (inbound/outbound). +type salesforceFeed struct{} + +type salesforceDoc struct { + CreateDate string `json:"createDate"` + Prefixes []struct { + IPPrefix string `json:"ip_prefix"` + Region string `json:"region"` + Direction string `json:"direction"` + } `json:"prefixes"` + IPv6Prefixes []struct { + IPv6Prefix string `json:"ipv6_prefix"` + Region string `json:"region"` + Direction string `json:"direction"` + } `json:"ipv6_prefixes"` +} + +func (salesforceFeed) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + var d salesforceDoc + if err := json.Unmarshal(data, &d); err != nil { + return nil, fmt.Errorf("salesforce: %w", err) + } + out := make([]model.Record, 0, len(d.Prefixes)+len(d.IPv6Prefixes)) + for _, p := range d.Prefixes { + r := meta.Base(retrievedAt) + r.Prefix = p.IPPrefix + r.Region = p.Region + r.Direction = p.Direction + r.SourceTimestamp = d.CreateDate + out = append(out, r) + } + for _, p := range d.IPv6Prefixes { + r := meta.Base(retrievedAt) + r.Prefix = p.IPv6Prefix + r.Region = p.Region + r.Direction = p.Direction + r.SourceTimestamp = d.CreateDate + out = append(out, r) + } + return out, nil +} diff --git a/internal/ipfeed/parse/opts.go b/internal/ipfeed/parse/opts.go new file mode 100644 index 0000000..6e4651e --- /dev/null +++ b/internal/ipfeed/parse/opts.go @@ -0,0 +1,37 @@ +package parse + +// opts provides typed access to a source's parser_opts map. YAML decodes +// scalars as int/bool/string, which these helpers coerce with defaults. +type opts map[string]any + +func (o opts) str(key, def string) string { + if v, ok := o[key]; ok { + if s, ok := v.(string); ok { + return s + } + } + return def +} + +func (o opts) int(key string, def int) int { + if v, ok := o[key]; ok { + switch n := v.(type) { + case int: + return n + case int64: + return int(n) + case float64: + return int(n) + } + } + return def +} + +func (o opts) boolean(key string, def bool) bool { + if v, ok := o[key]; ok { + if b, ok := v.(bool); ok { + return b + } + } + return def +} diff --git a/internal/ipfeed/parse/parse_bench_test.go b/internal/ipfeed/parse/parse_bench_test.go new file mode 100644 index 0000000..1412f04 --- /dev/null +++ b/internal/ipfeed/parse/parse_bench_test.go @@ -0,0 +1,93 @@ +package parse + +import ( + "fmt" + "strings" + "testing" +) + +// benchMeta is a minimal source meta shared by the parser benchmarks. +var benchMeta = SourceMeta{ + Name: "bench", + Provider: "bench", + URL: "https://example/feed", + SourceType: "provider_feed", + Confidence: "authoritative", +} + +const benchTS = "2026-01-01T00:00:00Z" + +// genAWSJSON builds an AWS ip-ranges.json body with n IPv4 prefix entries. +func genAWSJSON(n int) []byte { + var b strings.Builder + b.WriteString(`{"createDate":"2026-01-01-00-00-00","prefixes":[`) + for i := range n { + if i > 0 { + b.WriteByte(',') + } + fmt.Fprintf(&b, `{"ip_prefix":"10.%d.%d.0/24","region":"us-east-1","service":"EC2","network_border_group":"us-east-1"}`, + (i>>8)&0xff, i&0xff) + } + b.WriteString(`],"ipv6_prefixes":[]}`) + return []byte(b.String()) +} + +// genTextCIDR builds n newline-delimited /24 lines. +func genTextCIDR(n int) []byte { + var b strings.Builder + for i := range n { + fmt.Fprintf(&b, "10.%d.%d.0/24\n", (i>>8)&0xff, i&0xff) + } + return []byte(b.String()) +} + +// genCSV builds n rows of "prefix,region". +func genCSV(n int) []byte { + var b strings.Builder + for i := range n { + fmt.Fprintf(&b, "10.%d.%d.0/24,us-east-1\n", (i>>8)&0xff, i&0xff) + } + return []byte(b.String()) +} + +// BenchmarkParse measures the decode hot path for the three representative +// feed shapes (JSON, text-CIDR, CSV) across dataset sizes. +func BenchmarkParse(b *testing.B) { + csvMeta := benchMeta + csvMeta.Opts = map[string]any{"has_header": false, "prefix_column": 0, "region_column": 1} + + cases := []struct { + parser string + meta SourceMeta + gen func(int) []byte + }{ + {"aws_ip_ranges", benchMeta, genAWSJSON}, + {"text_cidr", benchMeta, genTextCIDR}, + {"csv", csvMeta, genCSV}, + } + + for i := range cases { + c := &cases[i] + p, ok := Get(c.parser) + if !ok { + b.Fatalf("parser %q not registered", c.parser) + } + for _, size := range []int{100, 10_000} { + data := c.gen(size) + b.Run(fmt.Sprintf("%s/n=%d", c.parser, size), func(b *testing.B) { + b.ReportAllocs() + b.SetBytes(int64(len(data))) + b.ResetTimer() + for range b.N { + recs, err := p.Parse(data, c.meta, benchTS) + if err != nil { + b.Fatalf("Parse: %v", err) + } + if len(recs) != size { + b.Fatalf("got %d records, want %d", len(recs), size) + } + } + }) + } + } +} diff --git a/internal/ipfeed/parse/parse_test.go b/internal/ipfeed/parse/parse_test.go new file mode 100644 index 0000000..ddacdc3 --- /dev/null +++ b/internal/ipfeed/parse/parse_test.go @@ -0,0 +1,212 @@ +package parse + +import ( + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +var testMeta = SourceMeta{ + Name: "t", + Provider: "prov", + URL: "https://example/feed", + SourceType: "provider_feed", + Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "owner", ServiceOperator: "op"}, +} + +const ts = "2026-01-01T00:00:00Z" + +func TestTextCIDR(t *testing.T) { + p, _ := Get("text_cidr") + tests := []struct { + name string + desc string + class string + in string + want []string + wantErr bool + }{ + {"positive", "positive: two plain CIDR lines become two records", "positive", + "1.2.3.0/24\n2001:db8::/32\n", []string{"1.2.3.0/24", "2001:db8::/32"}, false}, + {"negative_passthrough", "negative: an invalid CIDR line is passed through for the combine stage to reject", "negative", + "garbage-line\n", []string{"garbage-line"}, false}, + {"boundary_empty", "boundary: empty body yields zero records", "boundary", + "", nil, false}, + {"boundary_bom_and_blank", "boundary: leading UTF-8 BOM and blank lines are stripped", "boundary", + "\xEF\xBB\xBF\n1.1.1.0/24\n\n", []string{"1.1.1.0/24"}, false}, + {"corner_comments_and_crlf", "corner: comments are skipped and CRLF is trimmed", "corner", + "# header\r\n9.9.9.0/24\r\n", []string{"9.9.9.0/24"}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), testMeta, ts) + checkPrefixes(t, tc.desc, got, err, tc.want, tc.wantErr) + }) + } +} + +func TestCSV(t *testing.T) { + p, _ := Get("csv") + // prefix in col0, region in col1 (AWS geo-feed style), no header. + meta := testMeta + meta.Opts = map[string]any{"has_header": false, "prefix_column": 0, "region_column": 1} + tests := []struct { + name string + desc string + class string + in string + want []string + wantErr bool + }{ + {"positive", "positive: two rows with prefix+region", "positive", + "1.2.3.0/24,US\n4.4.0.0/16,DE\n", []string{"1.2.3.0/24", "4.4.0.0/16"}, false}, + {"negative_badcsv", "negative: an unterminated quote is a CSV error", "negative", + "1.2.3.0/24,\"US\n", nil, true}, + {"boundary_empty", "boundary: empty input yields no records", "boundary", + "", nil, false}, + {"boundary_short_row", "boundary: a row missing the prefix column is skipped", "boundary", + "\n2.2.2.0/24,US\n", []string{"2.2.2.0/24"}, false}, + {"corner_ragged_and_bom", "corner: ragged extra columns tolerated, BOM stripped", "corner", + "\xEF\xBB\xBF3.3.3.0/24,US,extra,cols\n", []string{"3.3.3.0/24"}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), meta, ts) + checkPrefixes(t, tc.desc, got, err, tc.want, tc.wantErr) + if tc.name == "positive" && err == nil { + if got[0].Region != "US" { + t.Errorf("%s: region = %q, want US", tc.desc, got[0].Region) + } + } + }) + } +} + +func TestAWSIPRanges(t *testing.T) { + p, _ := Get("aws_ip_ranges") + tests := []struct { + name string + desc string + class string + in string + want []string + wantErr bool + }{ + {"positive", "positive: v4 and v6 prefixes with metadata", "positive", + `{"createDate":"2026-01-01","prefixes":[{"ip_prefix":"13.248.0.0/16","region":"GLOBAL","service":"AMAZON","network_border_group":"g"}],"ipv6_prefixes":[{"ipv6_prefix":"2600:1f00::/24","region":"us-east-1","service":"EC2"}]}`, + []string{"13.248.0.0/16", "2600:1f00::/24"}, false}, + {"negative_badjson", "negative: malformed JSON errors", "negative", + `{"prefixes":[`, nil, true}, + {"boundary_empty_arrays", "boundary: empty arrays yield no records", "boundary", + `{"prefixes":[],"ipv6_prefixes":[]}`, nil, false}, + {"corner_unknown_fields", "corner: unknown top-level fields are ignored", "corner", + `{"syncToken":"x","extra":true,"prefixes":[{"ip_prefix":"1.0.0.0/24","region":"r","service":"S"}]}`, + []string{"1.0.0.0/24"}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), testMeta, ts) + checkPrefixes(t, tc.desc, got, err, tc.want, tc.wantErr) + if tc.name == "positive" && err == nil { + if got[0].Service != "AMAZON" || got[0].NetworkBorderGroup != "g" || got[0].SourceTimestamp != "2026-01-01" { + t.Errorf("%s: metadata not carried: %+v", tc.desc, got[0]) + } + } + }) + } +} + +func TestPrefixesFeed(t *testing.T) { + p, _ := Get("gcp_ipranges") + tests := []struct { + name string + desc string + class string + in string + want []string + wantErr bool + }{ + {"positive", "positive: mixed ipv4Prefix/ipv6Prefix entries", "positive", + `{"creationTime":"2026","prefixes":[{"ipv4Prefix":"34.0.0.0/8","service":"Google Cloud","scope":"us"},{"ipv6Prefix":"2600::/16"}]}`, + []string{"34.0.0.0/8", "2600::/16"}, false}, + {"negative_badjson", "negative: malformed JSON errors", "negative", `{`, nil, true}, + {"boundary_empty", "boundary: empty prefixes array yields nothing", "boundary", + `{"prefixes":[]}`, nil, false}, + {"corner_empty_entry", "corner: an entry with neither v4 nor v6 is skipped", "corner", + `{"prefixes":[{"service":"x"},{"ipv4Prefix":"8.8.8.0/24"}]}`, []string{"8.8.8.0/24"}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), testMeta, ts) + checkPrefixes(t, tc.desc, got, err, tc.want, tc.wantErr) + }) + } +} + +func TestGithubMeta(t *testing.T) { + p, _ := Get("github_meta") + tests := []struct { + name string + desc string + class string + in string + want []string + wantErr bool + }{ + {"positive", "positive: service arrays flattened, key becomes service (sorted keys)", "positive", + `{"api":["1.1.1.0/24"],"hooks":["2.2.2.0/24"]}`, + []string{"1.1.1.0/24", "2.2.2.0/24"}, false}, + {"negative_badjson", "negative: malformed JSON errors", "negative", `not json`, nil, true}, + {"boundary_empty", "boundary: empty object yields nothing", "boundary", `{}`, nil, false}, + {"corner_nonarray_values", "corner: non-array values (bool/object) are ignored", "corner", + `{"verifiable_password_authentication":false,"ssh_key_fingerprints":{"a":"b"},"web":["3.3.3.0/24"]}`, + []string{"3.3.3.0/24"}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), testMeta, ts) + checkPrefixes(t, tc.desc, got, err, tc.want, tc.wantErr) + if tc.name == "positive" && err == nil { + if got[0].Service != "api" { + t.Errorf("%s: service = %q, want api", tc.desc, got[0].Service) + } + } + }) + } +} + +func TestBaseMetadataApplied(t *testing.T) { + p, _ := Get("text_cidr") + got, err := p.Parse([]byte("1.2.3.0/24\n"), testMeta, ts) + if err != nil || len(got) != 1 { + t.Fatalf("unexpected: %v %d", err, len(got)) + } + r := got[0] + if r.NetworkOwner != "owner" || r.Provider != "prov" || r.SourceURL != "https://example/feed" || + r.SourceType != "provider_feed" || r.Confidence != "authoritative" || r.RetrievedAt != ts { + t.Errorf("base metadata not applied: %+v", r) + } +} + +// checkPrefixes asserts the error expectation and the ordered prefix list. +func checkPrefixes(t *testing.T, desc string, got []model.Record, err error, want []string, wantErr bool) { + t.Helper() + if wantErr { + if err == nil { + t.Fatalf("%s: expected error, got nil", desc) + } + return + } + if err != nil { + t.Fatalf("%s: unexpected error: %v", desc, err) + } + if len(got) != len(want) { + t.Fatalf("%s: got %d records, want %d", desc, len(got), len(want)) + } + for i, w := range want { + if got[i].Prefix != w { + t.Errorf("%s: record[%d].Prefix = %q, want %q", desc, i, got[i].Prefix, w) + } + } +} diff --git a/internal/ipfeed/parse/registry.go b/internal/ipfeed/parse/registry.go new file mode 100644 index 0000000..28c19db --- /dev/null +++ b/internal/ipfeed/parse/registry.go @@ -0,0 +1,95 @@ +// Package parse turns a fetched feed body into normalized model.Records. +// +// Each feed format is handled by a Parser registered under a string key (the +// `parser:` field in a source config). Parsers set only the feed-derived +// fields (prefix + any service/region/direction metadata) on top of a base +// record built from the source's defaults; CIDR validation and ip_version +// derivation happen later in the combine stage, so parsers never need to touch +// net/netip themselves. +package parse + +import "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" + +// Defaults are record fields applied to every row a source produces, before +// the parser overlays feed-specific values. +type Defaults struct { + NetworkOwner string + ServiceOperator string + Service string + Product string + Region string + Direction string +} + +// SourceMeta is the subset of a source config that parsers need. It is a +// plain struct (not the config type) so the parse package does not depend on +// the config package, keeping the dependency edge one-directional. +type SourceMeta struct { + Name string + Provider string + URL string + SourceType string + Confidence string + Defaults Defaults + Opts map[string]any +} + +// Base returns a record pre-filled with the source's provenance and default +// fields. Parsers copy this and set Prefix (+ optional overrides) per row. +func (m SourceMeta) Base(retrievedAt string) model.Record { + return model.Record{ + NetworkOwner: m.Defaults.NetworkOwner, + ServiceOperator: m.Defaults.ServiceOperator, + Provider: m.Provider, + Service: m.Defaults.Service, + Product: m.Defaults.Product, + Region: m.Defaults.Region, + Direction: m.Defaults.Direction, + SourceName: m.Name, + SourceType: m.SourceType, + SourceURL: m.URL, + RetrievedAt: retrievedAt, + Confidence: m.Confidence, + } +} + +// Parser converts a raw feed body into records. Implementations must not +// perform network I/O and should be deterministic for a given input. +type Parser interface { + // Parse returns the records found in data. retrievedAt is an RFC3339 UTC + // timestamp for the fetch, stamped onto every record. + Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) +} + +var registry = map[string]Parser{} + +// Register adds a parser under name. It panics on a duplicate name, since that +// is a programming error discoverable at init time. +func Register(name string, p Parser) { + if _, dup := registry[name]; dup { + panic("parse: duplicate parser registered: " + name) + } + registry[name] = p +} + +// Get returns the parser registered under name. +func Get(name string) (Parser, bool) { + p, ok := registry[name] + return p, ok +} + +// Registered reports whether a parser key is known. Used by config validation. +func Registered(name string) bool { + _, ok := registry[name] + return ok +} + +// Names returns the sorted-insertion-agnostic set of registered parser keys +// (used in error messages). +func Names() []string { + out := make([]string, 0, len(registry)) + for k := range registry { + out = append(out, k) + } + return out +} diff --git a/internal/ipfeed/parse/text_cidr.go b/internal/ipfeed/parse/text_cidr.go new file mode 100644 index 0000000..ab6318d --- /dev/null +++ b/internal/ipfeed/parse/text_cidr.go @@ -0,0 +1,40 @@ +package parse + +import ( + "bufio" + "bytes" + "strings" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +func init() { Register("text_cidr", textCIDR{}) } + +// utf8BOM is the UTF-8 byte-order mark, stripped from feed bodies that include +// it (kept as raw bytes so this source file itself carries no BOM). +var utf8BOM = []byte{0xEF, 0xBB, 0xBF} + +// textCIDR parses feeds that are one CIDR per line (e.g. Cloudflare's +// ips-v4 / ips-v6). Blank lines and `#` comments are ignored. Validation of +// each prefix happens later in the combine stage. +type textCIDR struct{} + +func (textCIDR) Parse(data []byte, meta SourceMeta, retrievedAt string) ([]model.Record, error) { + data = bytes.TrimPrefix(data, utf8BOM) + var out []model.Record + sc := bufio.NewScanner(bytes.NewReader(data)) + sc.Buffer(make([]byte, 0, 64*1024), 4*1024*1024) + for sc.Scan() { + line := strings.TrimSpace(sc.Text()) + if line == "" || strings.HasPrefix(line, "#") { + continue + } + r := meta.Base(retrievedAt) + r.Prefix = line + out = append(out, r) + } + if err := sc.Err(); err != nil { + return nil, err + } + return out, nil +} diff --git a/internal/ipfeed/s3/uploader.go b/internal/ipfeed/s3/uploader.go new file mode 100644 index 0000000..daec218 --- /dev/null +++ b/internal/ipfeed/s3/uploader.go @@ -0,0 +1,114 @@ +// Package s3 uploads the combined Parquet file to an S3-compatible bucket +// using minio-go v7, matching the credential and endpoint handling used by the +// xtcp2 s3parquet destination (static V4 creds, scheme-derived TLS, and the +// Docker `_FILE` secret convention handled by the caller). +package s3 + +import ( + "context" + "fmt" + "io" + "os" + "strings" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" +) + +// Config holds S3 connection and object placement settings. +type Config struct { + Endpoint string // may include http:// or https:// scheme + Bucket string + Region string + Prefix string // key prefix; joined with the filename + AccessKey string + SecretKey string + SkipBucketProbe bool +} + +// Uploader is the seam used by the collector; a fake implements it in tests. +type Uploader interface { + Put(ctx context.Context, key string, body io.Reader, size int64) (string, error) +} + +// minioUploader is the production Uploader backed by a *minio.Client. +type minioUploader struct { + client *minio.Client + cfg Config +} + +// New builds a minio-backed Uploader. The endpoint scheme selects TLS and is +// stripped to a bare host, mirroring the xtcp2 s3parquet client. When +// SkipBucketProbe is false it verifies the bucket exists up front. +func New(ctx context.Context, cfg Config) (Uploader, error) { + if cfg.Bucket == "" { + return nil, fmt.Errorf("s3: bucket is required") + } + endpoint := cfg.Endpoint + secure := true + switch { + case strings.HasPrefix(endpoint, "https://"): + endpoint = strings.TrimPrefix(endpoint, "https://") + secure = true + case strings.HasPrefix(endpoint, "http://"): + endpoint = strings.TrimPrefix(endpoint, "http://") + secure = false + } + endpoint = strings.TrimSuffix(endpoint, "/") + region := cfg.Region + if region == "" { + region = "us-east-1" + } + cl, err := minio.New(endpoint, &minio.Options{ + Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""), + Secure: secure, + Region: region, + }) + if err != nil { + return nil, fmt.Errorf("s3: new client: %w", err) + } + if !cfg.SkipBucketProbe { + exists, err := cl.BucketExists(ctx, cfg.Bucket) + if err != nil { + return nil, fmt.Errorf("s3: bucket probe: %w", err) + } + if !exists { + return nil, fmt.Errorf("s3: bucket %q does not exist", cfg.Bucket) + } + } + return &minioUploader{client: cl, cfg: cfg}, nil +} + +// Key joins the configured prefix with filename, e.g. "prefix/2026-09-09.parquet". +func (cfg Config) Key(filename string) string { + p := strings.Trim(cfg.Prefix, "/") + if p == "" { + return filename + } + return p + "/" + filename +} + +// Put uploads body of the given size under key and returns the s3:// URL. +func (u *minioUploader) Put(ctx context.Context, key string, body io.Reader, size int64) (string, error) { + _, err := u.client.PutObject(ctx, u.cfg.Bucket, key, body, size, minio.PutObjectOptions{ + ContentType: "application/octet-stream", + }) + if err != nil { + return "", fmt.Errorf("s3: put %s: %w", key, err) + } + return fmt.Sprintf("s3://%s/%s", u.cfg.Bucket, key), nil +} + +// SecretFromFile reads a secret from path (the Docker `_FILE` convention), +// trimming surrounding whitespace. An empty path returns "" with no error so +// callers can fall back to a direct value. +func SecretFromFile(path string) (string, error) { + if path == "" { + return "", nil + } + b, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("s3: read secret file: %w", err) + } + return strings.TrimSpace(string(b)), nil +} diff --git a/internal/ipfeed/s3/uploader_test.go b/internal/ipfeed/s3/uploader_test.go new file mode 100644 index 0000000..93a1edd --- /dev/null +++ b/internal/ipfeed/s3/uploader_test.go @@ -0,0 +1,74 @@ +package s3 + +import ( + "os" + "path/filepath" + "testing" +) + +func TestConfigKey(t *testing.T) { + tests := []struct { + name string + desc string + class string + prefix string + filename string + want string + }{ + {"positive_prefix", "positive: prefix and filename are joined with a slash", "positive", + "ipfeeds", "2026-09-09-14-30.parquet", "ipfeeds/2026-09-09-14-30.parquet"}, + {"boundary_empty_prefix", "boundary: an empty prefix returns just the filename", "boundary", + "", "2026-09-09-14-30.parquet", "2026-09-09-14-30.parquet"}, + {"corner_slashy_prefix", "corner: surrounding slashes on the prefix are trimmed", "corner", + "/a/b/", "f.parquet", "a/b/f.parquet"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + cfg := Config{Prefix: tc.prefix} + if got := cfg.Key(tc.filename); got != tc.want { + t.Errorf("%s: Key = %q, want %q", tc.desc, got, tc.want) + } + }) + } +} + +func TestSecretFromFile(t *testing.T) { + dir := t.TempDir() + good := filepath.Join(dir, "secret") + if err := os.WriteFile(good, []byte(" s3cr3t\n"), 0o600); err != nil { + t.Fatal(err) + } + + tests := []struct { + name string + desc string + class string + path string + want string + wantErr bool + }{ + {"positive_trimmed", "positive: file contents are read and whitespace-trimmed", "positive", + good, "s3cr3t", false}, + {"boundary_empty_path", "boundary: an empty path returns empty with no error", "boundary", + "", "", false}, + {"negative_missing", "negative: a missing file errors", "negative", + filepath.Join(dir, "nope"), "", true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := SecretFromFile(tc.path) + if tc.wantErr { + if err == nil { + t.Fatalf("%s: expected error, got nil", tc.desc) + } + return + } + if err != nil { + t.Fatalf("%s: unexpected error: %v", tc.desc, err) + } + if got != tc.want { + t.Errorf("%s: got %q, want %q", tc.desc, got, tc.want) + } + }) + } +} diff --git a/internal/ipfeed/summary/summary.go b/internal/ipfeed/summary/summary.go new file mode 100644 index 0000000..b43da8c --- /dev/null +++ b/internal/ipfeed/summary/summary.go @@ -0,0 +1,109 @@ +// Package summary accumulates per-source outcomes and prints the end-of-run +// report: files processed and records processed, with explicit positive +// (valid) and negative (rejected) boundaries. +package summary + +import ( + "fmt" + "io" + "sort" + "text/tabwriter" + "time" +) + +// SourceResult is the outcome for one source. +type SourceResult struct { + Name string + OK bool + HTTPStatus int + FetchedBytes int64 + Parsed int // rows the parser produced + Valid int // positive (+) boundary + Rejected int // negative (-) boundary + Duration time.Duration + Note string // failure reason or extra context +} + +// Summary collects SourceResults and computes totals. +type Summary struct { + Sources []SourceResult +} + +// Add records one source's result. +func (s *Summary) Add(r SourceResult) { s.Sources = append(s.Sources, r) } + +// OKCount returns the number of successful sources. +func (s *Summary) OKCount() int { + n := 0 + for _, r := range s.Sources { + if r.OK { + n++ + } + } + return n +} + +// FailCount returns the number of failed sources. +func (s *Summary) FailCount() int { return len(s.Sources) - s.OKCount() } + +// TotalValid returns the summed positive boundary across sources. +func (s *Summary) TotalValid() int { + n := 0 + for _, r := range s.Sources { + n += r.Valid + } + return n +} + +// TotalRejected returns the summed negative boundary across sources. +func (s *Summary) TotalRejected() int { + n := 0 + for _, r := range s.Sources { + n += r.Rejected + } + return n +} + +// Print renders the report to w. uploadURL/uploadBytes describe the uploaded +// object (empty uploadURL means no upload happened). +func (s *Summary) Print(w io.Writer, uploadURL string, uploadBytes int64) { + rows := append([]SourceResult(nil), s.Sources...) + sort.Slice(rows, func(i, j int) bool { return rows[i].Name < rows[j].Name }) + + tw := tabwriter.NewWriter(w, 0, 2, 2, ' ', 0) + fmt.Fprintln(tw, "source\tstatus\thttp\tfetched\tparsed\t+valid\t-rejected\tdur\tnote") + for _, r := range rows { + status := "ok" + if !r.OK { + status = "FAIL" + } + http := "-" + if r.HTTPStatus > 0 { + http = fmt.Sprintf("%d", r.HTTPStatus) + } + fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t%d\t%d\t%d\t%s\t%s\n", + r.Name, status, http, humanBytes(r.FetchedBytes), + r.Parsed, r.Valid, r.Rejected, r.Duration.Round(time.Millisecond), r.Note) + } + // #nosec G104 -- summary printer: a flush error to the report writer is not actionable + tw.Flush() //nolint:errcheck,gosec // summary printer: a flush error to the report writer is not actionable + + fmt.Fprintf(w, "\nTOTALS %d ok / %d fail records: %d valid (+) / %d rejected (-)\n", + s.OKCount(), s.FailCount(), s.TotalValid(), s.TotalRejected()) + if uploadURL != "" { + fmt.Fprintf(w, "uploaded: %s (%s)\n", uploadURL, humanBytes(uploadBytes)) + } +} + +func humanBytes(n int64) string { + const unit = 1024 + if n < unit { + return fmt.Sprintf("%d B", n) + } + div, exp := int64(unit), 0 + for x := n / unit; x >= unit; x /= unit { + div *= unit + exp++ + } + return fmt.Sprintf("%.1f %cB", float64(n)/float64(div), "KMGTPE"[exp]) +} diff --git a/internal/ipfeed/telemetry/otel.go b/internal/ipfeed/telemetry/otel.go new file mode 100644 index 0000000..fa9c60d --- /dev/null +++ b/internal/ipfeed/telemetry/otel.go @@ -0,0 +1,131 @@ +// Package telemetry wires OpenTelemetry (OTLP over HTTP) metrics and traces +// for the collector. If no OTLP endpoint is configured (the standard +// OTEL_EXPORTER_OTLP_ENDPOINT env var is empty), providers are still created +// but without exporters, so the tool runs fine with no collector attached. +package telemetry + +import ( + "context" + "os" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp" + "go.opentelemetry.io/otel/metric" + sdkmetric "go.opentelemetry.io/otel/sdk/metric" + "go.opentelemetry.io/otel/sdk/resource" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + "go.opentelemetry.io/otel/trace" +) + +// Telemetry holds the tracer and metric instruments used across the pipeline. +type Telemetry struct { + Tracer trace.Tracer + + FetchBytes metric.Int64Counter + FetchAttempts metric.Int64Counter + FetchFailures metric.Int64Counter + RecordsValid metric.Int64Counter + RecordsInvalid metric.Int64Counter + UploadBytes metric.Int64Counter + Cycles metric.Int64Counter // collection cycles, attr outcome=success|failure + FetchDuration metric.Float64Histogram + ParseDuration metric.Float64Histogram + SourcesSucceeded metric.Int64Gauge + + shutdown []func(context.Context) error +} + +// Setup builds trace and metric providers for serviceName and returns a +// Telemetry with all instruments created. Call Telemetry.Shutdown to flush. +func Setup(ctx context.Context, serviceName string) (*Telemetry, error) { + // Use a schemaless resource for the service.name attribute so it merges + // cleanly with resource.Default() regardless of the SDK's schema version. + res, err := resource.Merge(resource.Default(), + resource.NewSchemaless(attribute.String("service.name", serviceName))) + if err != nil { + return nil, err + } + + t := &Telemetry{} + endpoint := os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") + + // Traces. + var tpOpts []sdktrace.TracerProviderOption + tpOpts = append(tpOpts, sdktrace.WithResource(res)) + if endpoint != "" { + texp, err := otlptracehttp.New(ctx) + if err != nil { + return nil, err + } + tpOpts = append(tpOpts, sdktrace.WithBatcher(texp)) + } + tp := sdktrace.NewTracerProvider(tpOpts...) + otel.SetTracerProvider(tp) + t.shutdown = append(t.shutdown, tp.Shutdown) + + // Metrics. + var mpOpts []sdkmetric.Option + mpOpts = append(mpOpts, sdkmetric.WithResource(res)) + if endpoint != "" { + mexp, err := otlpmetrichttp.New(ctx) + if err != nil { + return nil, err + } + mpOpts = append(mpOpts, sdkmetric.WithReader(sdkmetric.NewPeriodicReader(mexp))) + } + mp := sdkmetric.NewMeterProvider(mpOpts...) + otel.SetMeterProvider(mp) + t.shutdown = append(t.shutdown, mp.Shutdown) + + t.Tracer = tp.Tracer("ipfeed-collector") + m := mp.Meter("ipfeed-collector") + + if t.FetchBytes, err = m.Int64Counter("ipfeed.fetch.bytes"); err != nil { + return nil, err + } + if t.FetchAttempts, err = m.Int64Counter("ipfeed.fetch.attempts"); err != nil { + return nil, err + } + if t.FetchFailures, err = m.Int64Counter("ipfeed.fetch.failures"); err != nil { + return nil, err + } + if t.RecordsValid, err = m.Int64Counter("ipfeed.records.valid"); err != nil { + return nil, err + } + if t.RecordsInvalid, err = m.Int64Counter("ipfeed.records.invalid"); err != nil { + return nil, err + } + if t.UploadBytes, err = m.Int64Counter("ipfeed.upload.bytes"); err != nil { + return nil, err + } + if t.Cycles, err = m.Int64Counter("ipfeed.cycles"); err != nil { + return nil, err + } + if t.FetchDuration, err = m.Float64Histogram("ipfeed.fetch.duration", metric.WithUnit("s")); err != nil { + return nil, err + } + if t.ParseDuration, err = m.Float64Histogram("ipfeed.parse.duration", metric.WithUnit("s")); err != nil { + return nil, err + } + if t.SourcesSucceeded, err = m.Int64Gauge("ipfeed.sources.succeeded"); err != nil { + return nil, err + } + return t, nil +} + +// Shutdown flushes and stops all providers. Errors are joined into the first +// non-nil result; a nil Telemetry is a no-op. +func (t *Telemetry) Shutdown(ctx context.Context) error { + if t == nil { + return nil + } + var firstErr error + for _, fn := range t.shutdown { + if err := fn(ctx); err != nil && firstErr == nil { + firstErr = err + } + } + return firstErr +} diff --git a/nix/binaries.nix b/nix/binaries.nix index cef80f8..a72cb29 100644 --- a/nix/binaries.nix +++ b/nix/binaries.nix @@ -50,6 +50,7 @@ let "clickhouse_http_insert_protobuflist" "clickhouse_protobuflist" "clickhouse_protobuflist_db" + "ipfeed-collector" "kafka_to_clickhouse" "ns" "nsTest" diff --git a/nix/checks/cli-help-smoke.nix b/nix/checks/cli-help-smoke.nix index bc3e89a..676793d 100644 --- a/nix/checks/cli-help-smoke.nix +++ b/nix/checks/cli-help-smoke.nix @@ -24,6 +24,7 @@ let "clickhouse_http_insert_protobuflist" "clickhouse_protobuflist" "clickhouse_protobuflist_db" + "ipfeed-collector" "kafka_to_clickhouse" "ns" "nsTest" diff --git a/nix/containers/default.nix b/nix/containers/default.nix index 5eb731d..86eb999 100644 --- a/nix/containers/default.nix +++ b/nix/containers/default.nix @@ -171,6 +171,20 @@ let binaries = binaries.${name}; entrypoint = "/bin/${name}"; }; + + # Self-contained HEALTHCHECK for the ipfeed-collector daemon image (scratch, + # no shell/curl): the binary probes its own /readyz via `-healthcheck`. + ipfeedHealthcheck = { + Test = [ + "CMD" + "/bin/ipfeed-collector" + "-healthcheck" + ]; + Interval = 30000000000; # 30s + Timeout = 5000000000; # 5s + StartPeriod = 15000000000; # 15s — grace while the first cycle runs + Retries = 3; + }; in { oci-xtcp2 = mkFatImage { @@ -197,6 +211,24 @@ in oci-xtcp2client = mkClientImage "xtcp2client"; oci-xtcp2ctl = mkClientImage "xtcp2ctl"; + # Slim single-binary image for the ipfeed-collector daemon: scratch + CA + # bundle, runs as a daemon on :8080 with a self-probe HEALTHCHECK. Feed + # definitions are provided at runtime (mount a dir and set -sources-dir / + # IPFEED_SOURCES_DIR); they are not baked into the image. + oci-ipfeed-collector = mkOciImage { + name = "ipfeed-collector"; + tag = "latest"; + binaries = binaries."ipfeed-collector"; + entrypoint = "/bin/ipfeed-collector"; + cmd = [ + "-daemon" + "-http-addr" + ":8080" + ]; + exposedPorts = [ 8080 ]; + healthcheck = ipfeedHealthcheck; + }; + # Phase B: tcp_server + tcp_client image, dispatched by TCP_MODE env. # Built so the Phase C docker-in-vm lifecycle harness can spin up # N containers (default 20) with M sockets each (default 100), with diff --git a/nix/default.nix b/nix/default.nix index 612f7bb..3b872bc 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -500,6 +500,8 @@ in oci-xtcp2client oci-xtcp2ctl ; + # ipfeed-collector daemon image (slim: single binary + CA bundle). + inherit (containers) oci-ipfeed-collector; # Phase B: TCP-stress container for the multi-container test # harness. Run with TCP_MODE=server|client|both, TCP_COUNT, diff --git a/nix/lib/mkOciImage.nix b/nix/lib/mkOciImage.nix index 2fd78f7..6652235 100644 --- a/nix/lib/mkOciImage.nix +++ b/nix/lib/mkOciImage.nix @@ -19,6 +19,9 @@ protoFile ? null, # path to the .proto file to ship at / exposedPorts ? [ ], entrypoint ? "/bin/xtcp2", + # Optional default arguments (image config `Cmd`), appended after the + # entrypoint. Only emitted when non-empty, so existing callers are unchanged. + cmd ? [ ], # Optional Docker HEALTHCHECK image-config block. Durations are integer # nanoseconds (Docker image-config convention), e.g. # { Test = [ "CMD" "/bin/xtcp2" "-healthcheck" ]; Interval = 30000000000; } @@ -63,5 +66,6 @@ pkgs.dockerTools.streamLayeredImage { # works even if Go's default search paths ever change. Env = [ "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt" ]; } + // lib.optionalAttrs (cmd != [ ]) { Cmd = cmd; } // lib.optionalAttrs (healthcheck != null) { Healthcheck = healthcheck; }; } diff --git a/nix/versions.nix b/nix/versions.nix index 52a8284..e642eb8 100644 --- a/nix/versions.nix +++ b/nix/versions.nix @@ -117,5 +117,5 @@ # Go vendor hash. Update by running `nix build .#xtcp2` and pasting the # `got:` value from the hash mismatch error. Used by every Nix check that # needs deps in the sandbox (see nix/lib/goModules.nix). - goVendorHash = "sha256-gvORPkTs1uJZhcSNWLdJzELX8FEE5QosfS6hP0N9n2E="; + goVendorHash = "sha256-FKOdkCYc/MqR+ArvdJc5h0ud1ONmlFs5IrVDwg/uKW4="; } diff --git a/pkg/ipasn/ipasn.go b/pkg/ipasn/ipasn.go new file mode 100644 index 0000000..a26b578 --- /dev/null +++ b/pkg/ipasn/ipasn.go @@ -0,0 +1,126 @@ +// Package ipasn provides a fast, in-process longest-prefix-match lookup from an +// IP address to its owning provider's representative ASN and network-owner +// name. +// +// It is the consumer side of the ipfeed-collector pipeline: the collector +// writes a Parquet artifact of prefix -> {asn, network_owner, …}; this package +// loads that artifact into an in-memory balanced-ART trie (github.com/gaissmai/ +// bart) and answers per-address lookups. It is designed to sit on xtcp2's +// per-socket enrichment hot path: +// +// - lookups are pure reads (no allocation, no syscalls, no locks); +// - the whole table is swapped atomically on Reload, so readers never see a +// partially built trie and never block a refresh. +// +// The ASN is a per-provider *representative* value (see internal/ipfeed/asnmap), +// not a per-prefix BGP-origin ASN. +package ipasn + +import ( + "errors" + "fmt" + "io" + "net/netip" + "os" + "sync/atomic" + + "github.com/gaissmai/bart" + "github.com/parquet-go/parquet-go" +) + +// Attr is the data attached to a matched prefix. +type Attr struct { + ASN uint32 + NetworkOwner string +} + +// row is the subset of the collector's Parquet schema this package reads. +// Field tags match internal/ipfeed/model.Record so parquet-go projects just +// these columns; keeping it local avoids coupling to the collector's model. +type row struct { + Prefix string `parquet:"prefix"` + ASN uint32 `parquet:"asn"` + NetworkOwner string `parquet:"network_owner"` +} + +// Index is a concurrency-safe IP->Attr lookup backed by an atomically-swapped +// trie. The zero value is not usable; construct with New. +type Index struct { + tbl atomic.Pointer[bart.Table[Attr]] +} + +// New builds an Index from the Parquet artifact at path. +func New(path string) (*Index, error) { + ix := &Index{} + if err := ix.Reload(path); err != nil { + return nil, err + } + return ix, nil +} + +// Reload builds a fresh trie from path and atomically swaps it in. On error the +// current table is left untouched, so a bad refresh never degrades a good +// table already in service. +func (ix *Index) Reload(path string) error { + t, err := build(path) + if err != nil { + return err + } + ix.tbl.Store(t) + return nil +} + +// Lookup returns the Attr of the longest prefix matching addr. The bool is +// false when nothing matches (or before the first successful load). addr is +// unmapped first so an IPv4-in-IPv6 address matches IPv4 prefixes. +func (ix *Index) Lookup(addr netip.Addr) (Attr, bool) { + t := ix.tbl.Load() + if t == nil { + return Attr{}, false + } + return t.Lookup(addr.Unmap()) +} + +// build reads the Parquet artifact at path and constructs the trie. Later +// inserts for an identical prefix win (feeds may classify one prefix under +// several owners; we keep the representative value seen last). +func build(path string) (*bart.Table[Attr], error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + + info, err := f.Stat() + if err != nil { + return nil, err + } + pf, err := parquet.OpenFile(f, info.Size()) + if err != nil { + return nil, fmt.Errorf("ipasn: open parquet %s: %w", path, err) + } + + reader := parquet.NewGenericReader[row](pf) + defer reader.Close() //nolint:errcheck // read-only reader; close error is not actionable + + t := new(bart.Table[Attr]) + buf := make([]row, 1024) + for { + n, err := reader.Read(buf) + for i := range n { + pfx, perr := netip.ParsePrefix(buf[i].Prefix) + if perr != nil { + continue // artifact is collector-canonicalized; skip any stray row + } + t.Insert(pfx, Attr{ASN: buf[i].ASN, NetworkOwner: buf[i].NetworkOwner}) + } + if err != nil { + // io.EOF (as parquet-go returns it) means we've read the last batch. + if n == 0 || errors.Is(err, io.EOF) { + break + } + return nil, fmt.Errorf("ipasn: read parquet %s: %w", path, err) + } + } + return t, nil +} diff --git a/pkg/ipasn/ipasn_test.go b/pkg/ipasn/ipasn_test.go new file mode 100644 index 0000000..f70f718 --- /dev/null +++ b/pkg/ipasn/ipasn_test.go @@ -0,0 +1,167 @@ +package ipasn + +import ( + "net/netip" + "os" + "path/filepath" + "sync" + "testing" + + "github.com/parquet-go/parquet-go" +) + +// writeArtifact writes rows to a temp Parquet file and returns its path. +func writeArtifact(t testing.TB, rows []row) string { + t.Helper() + path := filepath.Join(t.TempDir(), "feeds.parquet") + f, err := os.Create(path) + if err != nil { + t.Fatalf("create: %v", err) + } + w := parquet.NewGenericWriter[row](f) + if _, err := w.Write(rows); err != nil { + t.Fatalf("write: %v", err) + } + if err := w.Close(); err != nil { + t.Fatalf("close writer: %v", err) + } + if err := f.Close(); err != nil { + t.Fatalf("close file: %v", err) + } + return path +} + +var fixtureRows = []row{ + {Prefix: "1.1.1.0/24", ASN: 13335, NetworkOwner: "cloudflare"}, + {Prefix: "8.8.8.0/24", ASN: 15169, NetworkOwner: "google"}, + {Prefix: "10.0.0.0/8", ASN: 111, NetworkOwner: "broad"}, + {Prefix: "10.1.0.0/16", ASN: 222, NetworkOwner: "specific"}, + {Prefix: "2606:4700::/32", ASN: 13335, NetworkOwner: "cloudflare"}, +} + +// TestLookup covers exact hits, LPM precedence, IPv6, v4-in-v6, and misses. +func TestLookup(t *testing.T) { + ix, err := New(writeArtifact(t, fixtureRows)) + if err != nil { + t.Fatalf("New: %v", err) + } + + tests := []struct { + name, desc, class string + addr string + wantOwner string + wantASN uint32 + wantOK bool + }{ + {"positive_v4_hit", "positive: an address inside a /24 resolves", "positive", + "1.1.1.5", "cloudflare", 13335, true}, + {"positive_v6_hit", "positive: an IPv6 address inside a /32 resolves", "positive", + "2606:4700::1", "cloudflare", 13335, true}, + {"boundary_lpm_more_specific", "boundary: the more-specific /16 wins over the /8", "boundary", + "10.1.2.3", "specific", 222, true}, + {"boundary_lpm_less_specific", "boundary: outside the /16 falls back to the /8", "boundary", + "10.9.9.9", "broad", 111, true}, + {"corner_v4_in_v6", "corner: a v4-in-v6 address is unmapped and matches the v4 prefix", "corner", + "::ffff:1.1.1.5", "cloudflare", 13335, true}, + {"negative_miss", "negative: an unmatched address yields (zero,false)", "negative", + "9.9.9.9", "", 0, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, ok := ix.Lookup(netip.MustParseAddr(tc.addr)) + if ok != tc.wantOK || got.NetworkOwner != tc.wantOwner || got.ASN != tc.wantASN { + t.Errorf("%s: Lookup(%s) = (%+v,%v), want owner=%q asn=%d ok=%v", + tc.desc, tc.addr, got, ok, tc.wantOwner, tc.wantASN, tc.wantOK) + } + }) + } +} + +// TestLookupBeforeLoad verifies a zero table (nil pointer) is a safe miss. +func TestLookupBeforeLoad(t *testing.T) { + var ix Index // zero value, never Reloaded + if _, ok := ix.Lookup(netip.MustParseAddr("1.1.1.1")); ok { + t.Error("boundary: lookup on an unloaded Index should be a miss") + } +} + +// TestReloadBadPath verifies a failed Reload leaves the existing table intact. +func TestReloadBadPath(t *testing.T) { + ix, err := New(writeArtifact(t, fixtureRows)) + if err != nil { + t.Fatalf("New: %v", err) + } + if err := ix.Reload("/nonexistent/feeds.parquet"); err == nil { + t.Fatal("negative: Reload of a missing file should error") + } + // The good table must still answer. + if got, ok := ix.Lookup(netip.MustParseAddr("1.1.1.5")); !ok || got.ASN != 13335 { + t.Errorf("corner: table degraded after a failed Reload: got (%+v,%v)", got, ok) + } +} + +func BenchmarkLookup(b *testing.B) { + ix, err := New(writeArtifact(b, fixtureRows)) + if err != nil { + b.Fatalf("New: %v", err) + } + addr := netip.MustParseAddr("10.1.2.3") + b.ReportAllocs() + for range b.N { + _, _ = ix.Lookup(addr) + } +} + +// TestReloadConcurrent runs many readers against continuous Reloads under +// -race, asserting no data race and that readers always see a valid table. +func TestReloadConcurrent(t *testing.T) { + path := writeArtifact(t, fixtureRows) + ix, err := New(path) + if err != nil { + t.Fatalf("New: %v", err) + } + + stop := make(chan struct{}) + + // 8 readers spin until told to stop. Each writes its own slot so the test + // itself introduces no data race and the compiler cannot elide the lookup. + const nReaders = 8 + sinks := make([]Attr, nReaders) + var readers sync.WaitGroup + addr := netip.MustParseAddr("1.1.1.5") + for i := range nReaders { + readers.Add(1) + go func() { + defer readers.Done() + for { + select { + case <-stop: + return + default: + sinks[i], _ = ix.Lookup(addr) + } + } + }() + } + + // 2 reloaders each do a bounded number of swaps. + var reloaders sync.WaitGroup + for range 2 { + reloaders.Add(1) + go func() { + defer reloaders.Done() + for range 50 { + if err := ix.Reload(path); err != nil { + t.Errorf("Reload: %v", err) + return + } + } + }() + } + + // Readers run concurrently with the reloaders; once the reloaders are done, + // signal the readers to stop and wait for them to drain. + reloaders.Wait() + close(stop) + readers.Wait() +} diff --git a/pkg/xtcp/destinations_s3parquet.go b/pkg/xtcp/destinations_s3parquet.go index 96006b5..e9e39bb 100644 --- a/pkg/xtcp/destinations_s3parquet.go +++ b/pkg/xtcp/destinations_s3parquet.go @@ -764,23 +764,24 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { SocketFd: r.SocketFd, NetlinkerId: r.NetlinkerId, - InetDiagMsgFamily: r.InetDiagMsgFamily, - InetDiagMsgState: r.InetDiagMsgState, - InetDiagMsgTimer: r.InetDiagMsgTimer, - InetDiagMsgRetrans: r.InetDiagMsgRetrans, - InetDiagMsgSocketSourcePort: r.InetDiagMsgSocketSourcePort, - InetDiagMsgSocketDestinationPort: r.InetDiagMsgSocketDestinationPort, - InetDiagMsgSocketSource: r.InetDiagMsgSocketSource, - InetDiagMsgSocketDestination: r.InetDiagMsgSocketDestination, - InetDiagMsgSocketInterface: r.InetDiagMsgSocketInterface, - InetDiagMsgSocketCookie: r.InetDiagMsgSocketCookie, - InetDiagMsgSocketDestAsn: r.InetDiagMsgSocketDestAsn, - InetDiagMsgSocketNextHopAsn: r.InetDiagMsgSocketNextHopAsn, - InetDiagMsgExpires: r.InetDiagMsgExpires, - InetDiagMsgRqueue: r.InetDiagMsgRqueue, - InetDiagMsgWqueue: r.InetDiagMsgWqueue, - InetDiagMsgUid: r.InetDiagMsgUid, - InetDiagMsgInode: r.InetDiagMsgInode, + InetDiagMsgFamily: r.InetDiagMsgFamily, + InetDiagMsgState: r.InetDiagMsgState, + InetDiagMsgTimer: r.InetDiagMsgTimer, + InetDiagMsgRetrans: r.InetDiagMsgRetrans, + InetDiagMsgSocketSourcePort: r.InetDiagMsgSocketSourcePort, + InetDiagMsgSocketDestinationPort: r.InetDiagMsgSocketDestinationPort, + InetDiagMsgSocketSource: r.InetDiagMsgSocketSource, + InetDiagMsgSocketDestination: r.InetDiagMsgSocketDestination, + InetDiagMsgSocketInterface: r.InetDiagMsgSocketInterface, + InetDiagMsgSocketCookie: r.InetDiagMsgSocketCookie, + InetDiagMsgSocketDestAsn: r.InetDiagMsgSocketDestAsn, + InetDiagMsgSocketNextHopAsn: r.InetDiagMsgSocketNextHopAsn, + InetDiagMsgSocketDestNetworkOwner: r.InetDiagMsgSocketDestNetworkOwner, + InetDiagMsgExpires: r.InetDiagMsgExpires, + InetDiagMsgRqueue: r.InetDiagMsgRqueue, + InetDiagMsgWqueue: r.InetDiagMsgWqueue, + InetDiagMsgUid: r.InetDiagMsgUid, + InetDiagMsgInode: r.InetDiagMsgInode, MemInfoRmem: r.MemInfoRmem, MemInfoWmem: r.MemInfoWmem, diff --git a/pkg/xtcp/destinations_s3parquet_schema.go b/pkg/xtcp/destinations_s3parquet_schema.go index c89f039..e60da54 100644 --- a/pkg/xtcp/destinations_s3parquet_schema.go +++ b/pkg/xtcp/destinations_s3parquet_schema.go @@ -41,23 +41,24 @@ type ParquetRow struct { SocketFd uint64 `parquet:"socket_fd,snappy"` NetlinkerId uint64 `parquet:"netlinker_id,snappy"` - InetDiagMsgFamily uint32 `parquet:"inet_diag_msg_family,snappy"` - InetDiagMsgState uint32 `parquet:"inet_diag_msg_state,snappy"` - InetDiagMsgTimer uint32 `parquet:"inet_diag_msg_timer,snappy"` - InetDiagMsgRetrans uint32 `parquet:"inet_diag_msg_retrans,snappy"` - InetDiagMsgSocketSourcePort uint32 `parquet:"inet_diag_msg_socket_source_port,snappy"` - InetDiagMsgSocketDestinationPort uint32 `parquet:"inet_diag_msg_socket_destination_port,snappy"` - InetDiagMsgSocketSource []byte `parquet:"inet_diag_msg_socket_source,zstd"` - InetDiagMsgSocketDestination []byte `parquet:"inet_diag_msg_socket_destination,zstd"` - InetDiagMsgSocketInterface uint32 `parquet:"inet_diag_msg_socket_interface,snappy"` - InetDiagMsgSocketCookie uint64 `parquet:"inet_diag_msg_socket_cookie,snappy"` - InetDiagMsgSocketDestAsn uint64 `parquet:"inet_diag_msg_socket_dest_asn,snappy"` - InetDiagMsgSocketNextHopAsn uint64 `parquet:"inet_diag_msg_socket_next_hop_asn,snappy"` - InetDiagMsgExpires uint32 `parquet:"inet_diag_msg_expires,snappy"` - InetDiagMsgRqueue uint32 `parquet:"inet_diag_msg_rqueue,snappy"` - InetDiagMsgWqueue uint32 `parquet:"inet_diag_msg_wqueue,snappy"` - InetDiagMsgUid uint32 `parquet:"inet_diag_msg_uid,snappy"` - InetDiagMsgInode uint32 `parquet:"inet_diag_msg_inode,snappy"` + InetDiagMsgFamily uint32 `parquet:"inet_diag_msg_family,snappy"` + InetDiagMsgState uint32 `parquet:"inet_diag_msg_state,snappy"` + InetDiagMsgTimer uint32 `parquet:"inet_diag_msg_timer,snappy"` + InetDiagMsgRetrans uint32 `parquet:"inet_diag_msg_retrans,snappy"` + InetDiagMsgSocketSourcePort uint32 `parquet:"inet_diag_msg_socket_source_port,snappy"` + InetDiagMsgSocketDestinationPort uint32 `parquet:"inet_diag_msg_socket_destination_port,snappy"` + InetDiagMsgSocketSource []byte `parquet:"inet_diag_msg_socket_source,zstd"` + InetDiagMsgSocketDestination []byte `parquet:"inet_diag_msg_socket_destination,zstd"` + InetDiagMsgSocketInterface uint32 `parquet:"inet_diag_msg_socket_interface,snappy"` + InetDiagMsgSocketCookie uint64 `parquet:"inet_diag_msg_socket_cookie,snappy"` + InetDiagMsgSocketDestAsn uint64 `parquet:"inet_diag_msg_socket_dest_asn,snappy"` + InetDiagMsgSocketNextHopAsn uint64 `parquet:"inet_diag_msg_socket_next_hop_asn,snappy"` + InetDiagMsgSocketDestNetworkOwner string `parquet:"inet_diag_msg_socket_dest_network_owner,snappy"` + InetDiagMsgExpires uint32 `parquet:"inet_diag_msg_expires,snappy"` + InetDiagMsgRqueue uint32 `parquet:"inet_diag_msg_rqueue,snappy"` + InetDiagMsgWqueue uint32 `parquet:"inet_diag_msg_wqueue,snappy"` + InetDiagMsgUid uint32 `parquet:"inet_diag_msg_uid,snappy"` + InetDiagMsgInode uint32 `parquet:"inet_diag_msg_inode,snappy"` MemInfoRmem uint32 `parquet:"mem_info_rmem,snappy"` MemInfoWmem uint32 `parquet:"mem_info_wmem,snappy"` diff --git a/pkg/xtcp/enrich.go b/pkg/xtcp/enrich.go index b10b03f..5956fa9 100644 --- a/pkg/xtcp/enrich.go +++ b/pkg/xtcp/enrich.go @@ -3,6 +3,7 @@ package xtcp import ( "context" "log" + "net/netip" "strings" "time" @@ -10,6 +11,7 @@ import ( "github.com/randomizedcoder/xtcp2/gen/go/xtcp_flat_record" "github.com/randomizedcoder/xtcp2/pkg/dockermeta" + "github.com/randomizedcoder/xtcp2/pkg/ipasn" "github.com/randomizedcoder/xtcp2/pkg/lldp" "github.com/randomizedcoder/xtcp2/pkg/nicinfo" "github.com/randomizedcoder/xtcp2/pkg/nsdiscover" @@ -97,6 +99,59 @@ func (x *XTCP) initEnrichers(ctx context.Context) { } x.initDockerEnricher(ctx) x.initUplinkEnrichers(ctx) + x.initAsnEnricher(ctx) +} + +// initAsnEnricher loads the ipfeed-collector Parquet artifact into an in-process +// longest-prefix-match trie for destination IP -> {ASN, network owner}. A +// load failure disables ASN enrichment (counter + log) without touching the +// rest of the daemon. When asn_refresh_interval > 0 a background goroutine +// reloads the artifact so a refreshed file is picked up without a restart; a +// failed reload leaves the in-service trie untouched. +func (x *XTCP) initAsnEnricher(ctx context.Context) { + if !x.config.EnrichAsnEnable { + return + } + path := x.config.AsnDbPath + if path == "" { + x.pC.WithLabelValues("initEnrichers", "asn", "error").Inc() + log.Printf("initAsnEnricher: ASN enrichment disabled (best-effort): asn_db_path is empty") + return + } + + idx, err := ipasn.New(path) + if err != nil { + x.pC.WithLabelValues("initEnrichers", "asn", "error").Inc() + log.Printf("initAsnEnricher: ASN enrichment disabled (best-effort): %v", err) + return + } + x.asnIndex = idx + x.pC.WithLabelValues("initEnrichers", "asn", "enabled").Inc() + if x.debugLevel > 10 { + log.Printf("initAsnEnricher: ASN enrichment enabled (db:%s)", path) + } + + interval := x.config.GetAsnRefreshInterval().AsDuration() + if interval <= 0 { + return // load-once; no background refresh + } + go func() { + ticker := time.NewTicker(interval) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + if err := idx.Reload(path); err != nil { + x.pC.WithLabelValues("refreshAsn", "reload", "error").Inc() + log.Printf("initAsnEnricher: ASN reload failed (keeping current table): %v", err) + continue + } + x.pC.WithLabelValues("refreshAsn", "reload", "ok").Inc() + } + } + }() } // initDockerEnricher builds the netns-inode -> container index over the Docker @@ -245,6 +300,33 @@ func (x *XTCP) applyEnrichment(r *xtcp_flat_record.XtcpFlatRecord) { r.Nsid = uint32(id) } } + + if x.asnIndex != nil { + if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok { + if a, found := x.asnIndex.Lookup(addr); found { + r.InetDiagMsgSocketDestAsn = uint64(a.ASN) + r.InetDiagMsgSocketDestNetworkOwner = a.NetworkOwner + } + } + } +} + +// destAddr converts the kernel's 16-byte __be32[4] destination slot to a +// netip.Addr, alloc-free. family is authoritative: the kernel stores an IPv4 +// address in the first 4 bytes of the 16-byte slot (rest zero), so it must not +// be read as IPv6. Returns ok=false for a short/absent buffer or unknown family. +func destAddr(family uint32, b []byte) (netip.Addr, bool) { + switch family { + case unix.AF_INET: + if len(b) >= 4 { + return netip.AddrFrom4([4]byte(b[:4])), true + } + case unix.AF_INET6: + if len(b) >= 16 { + return netip.AddrFrom16([16]byte(b[:16])).Unmap(), true + } + } + return netip.Addr{}, false } // refreshNsids rebuilds the opt-in netns-inode -> nsid snapshot for the current diff --git a/pkg/xtcp/xtcp.go b/pkg/xtcp/xtcp.go index b8559af..64ff10e 100644 --- a/pkg/xtcp/xtcp.go +++ b/pkg/xtcp/xtcp.go @@ -20,6 +20,7 @@ import ( "github.com/randomizedcoder/xtcp2/gen/go/xtcp_flat_record" "github.com/randomizedcoder/xtcp2/pkg/cgroupid" "github.com/randomizedcoder/xtcp2/pkg/dockermeta" + "github.com/randomizedcoder/xtcp2/pkg/ipasn" "github.com/randomizedcoder/xtcp2/pkg/misc" "github.com/randomizedcoder/xtcp2/pkg/nsdiscover" "github.com/randomizedcoder/xtcp2/pkg/xsync" @@ -116,6 +117,12 @@ type XTCP struct { uplinkStamp uplinkStamp nsidByInode atomic.Pointer[map[uint64]int32] + // asnIndex maps a destination IP -> {ASN, network owner} via longest-prefix + // match over the ipfeed-collector artifact. Loaded once at startup and + // (optionally) refreshed by a background goroutine; read lock-free on the + // stamping path. nil unless enrich_asn_enable and a readable asn_db_path. + asnIndex *ipasn.Index + RTATypeDeserializer map[int]func(buf []byte, xtcpRecord *xtcp_flat_record.XtcpFlatRecord) (err error) RTATypeDeserializerStr map[int]string diff --git a/proto/xtcp_config/v1/xtcp_config.proto b/proto/xtcp_config/v1/xtcp_config.proto index 9f4f05c..385e703 100644 --- a/proto/xtcp_config/v1/xtcp_config.proto +++ b/proto/xtcp_config/v1/xtcp_config.proto @@ -859,6 +859,22 @@ message XtcpConfig { // Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for // Docker/containerd namespaces. Default false. bool populate_nsid = 238; + + // Enrich the destination IP's ASN (field 1011) and network owner (field + // 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + // artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when + // enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, + // and leaves both columns empty. Default false. + bool enrich_asn_enable = 239; + + // Path to the ipfeed-collector Parquet artifact (prefix -> {asn, + // network_owner}). Default "". + string asn_db_path = 240 [ + (buf.validate.field).string = { max_len: 255 }]; + + // How often to reload asn_db_path in the background so a refreshed artifact + // is picked up without a restart. 0 = load once at startup, never reload. + google.protobuf.Duration asn_refresh_interval = 241; }; message EnabledDeserializers { diff --git a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto index 159794f..c4e8794 100644 --- a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto +++ b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto @@ -175,6 +175,12 @@ message XtcpFlatRecord { uint32 inet_diag_msg_uid = 1016; uint32 inet_diag_msg_inode = 1017; + // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range + // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the + // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the + // destination IP is not in the feed set. + string inet_diag_msg_socket_dest_network_owner = 1018; + // might want to put more here // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 From dff917bc91cf4a78fa5d42427188cd1645568ebc Mon Sep 17 00:00:00 2001 From: "randomizedcoder dave.seddon.ca@gmail.com" Date: Wed, 9 Sep 2026 17:58:32 -0700 Subject: [PATCH 2/4] fix(gosec): handle previously-ignored errors instead of suppressing them The standalone go-sec check (gosec, G104 not excluded) flags unhandled errors that golangci `//nolint` does not silence. Rather than annotate them, handle each error for real so `nix build .#checks..go-sec` reports zero issues: - fetch: a 304 carries no body (RFC 7232) so drop that drain entirely; route the error-path drains through drainStatusErr, which folds any drain failure into the returned HTTP-status error. - summary: Print now returns the tabwriter flush error; both callers in cmd/ipfeed-collector handle it. - dockermeta: drainClose logs a drain failure (it only forfeits reuse). - lldp: a SetDeadline failure now aborts Fetch (the conn is unusable). - nsdiscover: if the recv timeout cannot be set, degrade to (0,false) rather than risk blocking the per-namespace reconcile path. - xtcp: a per-namespace handle close failure is logged. No behavior change on the success paths; go-sec: Issues 0. Co-Authored-By: Claude Opus 4.8 --- cmd/ipfeed-collector/main.go | 8 ++++++-- internal/ipfeed/fetch/fetch.go | 22 ++++++++++++++-------- internal/ipfeed/summary/summary.go | 11 +++++++---- pkg/dockermeta/dockermeta.go | 5 ++++- pkg/lldp/lldp.go | 4 +++- pkg/nsdiscover/nsid.go | 8 +++++--- pkg/xtcp/enrich.go | 6 +++++- 7 files changed, 44 insertions(+), 20 deletions(-) diff --git a/cmd/ipfeed-collector/main.go b/cmd/ipfeed-collector/main.go index d96dd93..1227fe3 100644 --- a/cmd/ipfeed-collector/main.go +++ b/cmd/ipfeed-collector/main.go @@ -395,7 +395,9 @@ func collectOnce(ctx context.Context, d deps) error { asnmap.Annotate(combined) if sum.OKCount() < f.minSuccess { - sum.Print(os.Stdout, "", 0) + if err := sum.Print(os.Stdout, "", 0); err != nil { + log.Error("print summary", "err", err) + } return fmt.Errorf("only %d/%d sources succeeded (min %d); not writing dataset", sum.OKCount(), len(sources), f.minSuccess) } @@ -431,7 +433,9 @@ func collectOnce(ctx context.Context, d deps) error { } } - sum.Print(os.Stdout, uploadURL, size) + if err := sum.Print(os.Stdout, uploadURL, size); err != nil { + return fmt.Errorf("print summary: %w", err) + } return nil } diff --git a/internal/ipfeed/fetch/fetch.go b/internal/ipfeed/fetch/fetch.go index af52c99..9e48ebb 100644 --- a/internal/ipfeed/fetch/fetch.go +++ b/internal/ipfeed/fetch/fetch.go @@ -158,8 +158,7 @@ func (c *Client) attempt(ctx context.Context, url string, cond Conditional) (Res switch { case resp.StatusCode == http.StatusNotModified: - // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused - io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse + // A 304 carries no message body (RFC 7232), so there is nothing to drain. res.NotModified = true return res, false, nil case resp.StatusCode >= 200 && resp.StatusCode < 300: @@ -170,16 +169,23 @@ func (c *Client) attempt(ctx context.Context, url string, cond Conditional) (Res res.Body = body return res, false, nil case resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500: - // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused - io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse - return res, true, fmt.Errorf("http status %d", resp.StatusCode) + return res, true, drainStatusErr(resp.Body, resp.StatusCode) default: - // #nosec G104 -- best-effort drain to enable connection reuse; body content is unused - io.Copy(io.Discard, resp.Body) //nolint:errcheck,gosec // best-effort drain to enable connection reuse - return res, false, fmt.Errorf("http status %d", resp.StatusCode) + return res, false, drainStatusErr(resp.Body, resp.StatusCode) } } +// drainStatusErr discards any remaining response body so the underlying +// connection can be reused for a retry, then returns an error naming the HTTP +// status. A drain failure is folded into the returned error rather than +// dropped. +func drainStatusErr(body io.Reader, code int) error { + if _, err := io.Copy(io.Discard, body); err != nil { + return fmt.Errorf("http status %d (body drain failed: %w)", code, err) + } + return fmt.Errorf("http status %d", code) +} + // cryptoJitter returns a uniform duration in [0, limit) using crypto/rand. func cryptoJitter(limit time.Duration) time.Duration { if limit <= 0 { diff --git a/internal/ipfeed/summary/summary.go b/internal/ipfeed/summary/summary.go index b43da8c..04fea84 100644 --- a/internal/ipfeed/summary/summary.go +++ b/internal/ipfeed/summary/summary.go @@ -65,8 +65,9 @@ func (s *Summary) TotalRejected() int { } // Print renders the report to w. uploadURL/uploadBytes describe the uploaded -// object (empty uploadURL means no upload happened). -func (s *Summary) Print(w io.Writer, uploadURL string, uploadBytes int64) { +// object (empty uploadURL means no upload happened). It returns any error from +// flushing the tabular section to w. +func (s *Summary) Print(w io.Writer, uploadURL string, uploadBytes int64) error { rows := append([]SourceResult(nil), s.Sources...) sort.Slice(rows, func(i, j int) bool { return rows[i].Name < rows[j].Name }) @@ -85,14 +86,16 @@ func (s *Summary) Print(w io.Writer, uploadURL string, uploadBytes int64) { r.Name, status, http, humanBytes(r.FetchedBytes), r.Parsed, r.Valid, r.Rejected, r.Duration.Round(time.Millisecond), r.Note) } - // #nosec G104 -- summary printer: a flush error to the report writer is not actionable - tw.Flush() //nolint:errcheck,gosec // summary printer: a flush error to the report writer is not actionable + if err := tw.Flush(); err != nil { + return fmt.Errorf("summary: flush table: %w", err) + } fmt.Fprintf(w, "\nTOTALS %d ok / %d fail records: %d valid (+) / %d rejected (-)\n", s.OKCount(), s.FailCount(), s.TotalValid(), s.TotalRejected()) if uploadURL != "" { fmt.Fprintf(w, "uploaded: %s (%s)\n", uploadURL, humanBytes(uploadBytes)) } + return nil } func humanBytes(n int64) string { diff --git a/pkg/dockermeta/dockermeta.go b/pkg/dockermeta/dockermeta.go index 0be0443..7763dad 100644 --- a/pkg/dockermeta/dockermeta.go +++ b/pkg/dockermeta/dockermeta.go @@ -413,7 +413,10 @@ func getJSON(ctx context.Context, client *http.Client, url string, v any) error // drainClose drains and closes a response body so the underlying connection can // be reused, then closes it. func drainClose(rc io.ReadCloser) { - io.Copy(io.Discard, rc) //nolint:errcheck,gosec // drain to enable connection reuse; body content is unused + if _, err := io.Copy(io.Discard, rc); err != nil { + // A drain failure only forfeits connection reuse; Close still frees it. + log.Printf("dockermeta: drain response body: %v", err) + } _ = rc.Close() } diff --git a/pkg/lldp/lldp.go b/pkg/lldp/lldp.go index 00abcb0..33a2323 100644 --- a/pkg/lldp/lldp.go +++ b/pkg/lldp/lldp.go @@ -148,7 +148,9 @@ func Fetch(ctx context.Context, socketPath, versionHint string) (map[string]Neig } defer conn.Close() //nolint:errcheck // best-effort close of a read-only control-socket conn if dl, ok := ctx.Deadline(); ok { - conn.SetDeadline(dl) //nolint:errcheck,gosec // best-effort deadline; a failure just means no timeout + if err := conn.SetDeadline(dl); err != nil { + return nil, fmt.Errorf("lldp: set deadline: %w", err) + } } if err := writeMsg(conn, opGetInterfaces, nil); err != nil { diff --git a/pkg/nsdiscover/nsid.go b/pkg/nsdiscover/nsid.go index 7af0364..82f9653 100644 --- a/pkg/nsdiscover/nsid.go +++ b/pkg/nsdiscover/nsid.go @@ -61,10 +61,12 @@ func Nsid(nsFD int) (int32, bool) { // Bound the receive so a missing/odd reply degrades to (0,false) instead of // blocking the caller (this runs per-namespace on the reconcile path). If the - // setsockopt is unsupported we still rely on the kernel's guaranteed reply to - // RTM_GETNSID, so the failure is non-fatal. + // recv timeout cannot be set we could block on a missing reply, so degrade to + // (0,false) rather than take that risk. tv := unix.Timeval{Sec: 1} - unix.SetsockoptTimeval(fd, unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv) //nolint:errcheck,gosec // best-effort recv timeout + if err := unix.SetsockoptTimeval(fd, unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv); err != nil { + return 0, false + } req := buildGetNsidRequest(nsFD) if err := unix.Sendto(fd, req, 0, &unix.SockaddrNetlink{Family: unix.AF_NETLINK}); err != nil { diff --git a/pkg/xtcp/enrich.go b/pkg/xtcp/enrich.go index 5956fa9..0699227 100644 --- a/pkg/xtcp/enrich.go +++ b/pkg/xtcp/enrich.go @@ -349,7 +349,11 @@ func (x *XTCP) refreshNsids(nss map[uint64]nsIdentity) { if nsid, ok := nsdiscover.Nsid(fd); ok { m[inode] = nsid } - unix.Close(fd) //nolint:errcheck,gosec // best-effort per-namespace handle close + if err := unix.Close(fd); err != nil { + // Best-effort: a failed close of a read-only handle is not + // recoverable here, but surface it for debugging. + log.Printf("refreshNsids: close ns handle: %v", err) + } } x.nsidByInode.Store(&m) x.pC.WithLabelValues("refreshNsids", "assigned", "counter").Add(float64(len(m))) From db40c798d8865c7c292f3929a93a1f3dc3e4dfdd Mon Sep 17 00:00:00 2001 From: "randomizedcoder dave.seddon.ca@gmail.com" Date: Wed, 9 Sep 2026 21:19:08 -0700 Subject: [PATCH 3/4] feat(locality): destination locality enrichment via native rtnetlink Classify each socket's destination as SELF / LOCAL_SUBNET / REMOTE using per-namespace address/route discovery over raw NETLINK_ROUTE (no vishvananda/netlink dependency), evaluated before the ipfeed IP->ASN lookup so on-host and on-link traffic skips the internet ASN feed. - pkg/xtcpnl: rtnetlink DUMP client + wire-format parsers (RTM_GETLINK/GETADDR/ GETROUTE), family-header deserializers, and DumpRtnetlink transport. Real nlmon-captured 7.1.8 fixtures (testdata/7_1_8) with a deterministic extract generator and real-fixture-driven, table-driven deserialize tests alongside the synthetic positive/negative/boundary/corner suites. - pkg/localnet: pure BuildSnapshot/Classify with an atomic-snapshot contract mirroring pkg/ipasn; table-driven + race + real-fixture end-to-end tests. - pkg/xtcp: per-namespace route-socket lifecycle, background refresh with atomic swap, and the dest-locality hot-path step in applyEnrichment. - record/config/schema plumbing: xtcp_flat_record + xtcp_config protos (+regen), parquet schema, ClickHouse DDL, recordfmt column/humanizer. - nix: reproducible `capture-netlink-fixtures` writeShellApplication (nlmon + tcpdump) wired into the modular nix/ tree. - docs/locality-enrichment.md design doc. The connected-subnet rule is family-agnostic (unicast + no gateway + has Dst): real captures show IPv4 connected subnets are scope-link but IPv6 connected subnets are scope-universe, so a scope-link gate would misclassify every IPv6 on-link subnet as REMOTE. Co-Authored-By: Claude Opus 4.8 --- .../format_schemas/xtcp_flat_record.proto | 15 + .../initdb.d/sql/xtcp_xtcp_flat_records.sql | 5 + .../sql/xtcp_xtcp_flat_records_kafka.sql | 5 + docs/locality-enrichment.md | 239 +++ gen/cpp/xtcp_config/v1/xtcp_config.pb.cc | 468 +++--- gen/cpp/xtcp_config/v1/xtcp_config.pb.h | 251 ++- .../v1/xtcp_flat_record.pb.cc | 1412 +++++++++-------- .../xtcp_flat_record/v1/xtcp_flat_record.pb.h | 617 ++++--- gen/dart/xtcp_config/v1/xtcp_config.pb.dart | 39 + .../xtcp_config/v1/xtcp_config.pbjson.dart | 25 +- .../v1/xtcp_flat_record.pb.dart | 590 +++---- .../v1/xtcp_flat_record.pbenum.dart | 35 + .../v1/xtcp_flat_record.pbjson.dart | 201 +-- gen/go/xtcp_config/xtcp_config.pb.go | 77 +- gen/go/xtcp_config/xtcp_config_vtproto.pb.go | 87 + .../xtcp_flat_record/xtcp_flat_record.pb.go | 133 +- .../xtcp_flat_record_vtproto.pb.go | 29 + .../xtcp_config/v1/xtcp_config.swagger.json | 8 + gen/python/xtcp_config/v1/xtcp_config_pb2.py | 16 +- gen/python/xtcp_config/v1/xtcp_config_pb2.pyi | 8 +- .../v1/xtcp_flat_record_pb2.py | 30 +- .../v1/xtcp_flat_record_pb2.pyi | 16 +- nix/capture-netlink-fixtures.nix | 129 ++ nix/default.nix | 10 + pkg/localnet/localnet.go | 169 ++ pkg/localnet/localnet_race_test.go | 108 ++ pkg/localnet/localnet_realfixtures_test.go | 152 ++ pkg/localnet/localnet_test.go | 304 ++++ pkg/recordfmt/columns.go | 2 + pkg/recordfmt/humanize.go | 10 + pkg/xtcp/destinations_s3parquet.go | 1 + pkg/xtcp/destinations_s3parquet_schema.go | 1 + pkg/xtcp/enrich.go | 19 +- pkg/xtcp/enrich_locality.go | 215 +++ pkg/xtcp/ns_discover.go | 7 + pkg/xtcp/xtcp.go | 11 + pkg/xtcpnl/testdata/7_1_8/ip_addr_n | 82 + pkg/xtcpnl/testdata/7_1_8/ip_link_n | 34 + .../testdata/7_1_8/ip_route_table_all_n | 74 + .../testdata/7_1_8/netlink_route_getaddr.pcap | Bin 0 -> 78216 bytes .../7_1_8/netlink_route_getaddr_v4_dump.pcap | Bin 0 -> 860 bytes .../7_1_8/netlink_route_getaddr_v6_dump.pcap | Bin 0 -> 1212 bytes .../testdata/7_1_8/netlink_route_getlink.pcap | Bin 0 -> 11264 bytes .../7_1_8/netlink_route_getlink_dump.pcap | Bin 0 -> 11096 bytes .../7_1_8/netlink_route_getroute.pcap | Bin 0 -> 18724 bytes .../7_1_8/netlink_route_getroute_dump.pcap | Bin 0 -> 7204 bytes pkg/xtcpnl/testdata/7_1_8/uname | 1 + pkg/xtcpnl/testdata_test.go | 23 + .../xtcpnl_extract_7_1_8_fixtures_test.go | 340 ++++ pkg/xtcpnl/xtcpnl_ifaddrmsg.go | 111 ++ pkg/xtcpnl/xtcpnl_ifinfomsg.go | 98 ++ pkg/xtcpnl/xtcpnl_rtmsg.go | 142 ++ pkg/xtcpnl/xtcpnl_rtnetlink.go | 189 +++ .../xtcpnl_rtnetlink_realfixtures_test.go | 412 +++++ pkg/xtcpnl/xtcpnl_rtnetlink_test.go | 880 ++++++++++ proto/xtcp_config/v1/xtcp_config.proto | 14 + .../v1/xtcp_flat_record.proto | 15 + 57 files changed, 6210 insertions(+), 1649 deletions(-) create mode 100644 docs/locality-enrichment.md create mode 100644 nix/capture-netlink-fixtures.nix create mode 100644 pkg/localnet/localnet.go create mode 100644 pkg/localnet/localnet_race_test.go create mode 100644 pkg/localnet/localnet_realfixtures_test.go create mode 100644 pkg/localnet/localnet_test.go create mode 100644 pkg/xtcp/enrich_locality.go create mode 100644 pkg/xtcpnl/testdata/7_1_8/ip_addr_n create mode 100644 pkg/xtcpnl/testdata/7_1_8/ip_link_n create mode 100644 pkg/xtcpnl/testdata/7_1_8/ip_route_table_all_n create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr_v4_dump.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr_v6_dump.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getlink.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getlink_dump.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getroute.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/netlink_route_getroute_dump.pcap create mode 100644 pkg/xtcpnl/testdata/7_1_8/uname create mode 100644 pkg/xtcpnl/xtcpnl_extract_7_1_8_fixtures_test.go create mode 100644 pkg/xtcpnl/xtcpnl_ifaddrmsg.go create mode 100644 pkg/xtcpnl/xtcpnl_ifinfomsg.go create mode 100644 pkg/xtcpnl/xtcpnl_rtmsg.go create mode 100644 pkg/xtcpnl/xtcpnl_rtnetlink.go create mode 100644 pkg/xtcpnl/xtcpnl_rtnetlink_realfixtures_test.go create mode 100644 pkg/xtcpnl/xtcpnl_rtnetlink_test.go diff --git a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto index 0ed3491..713d608 100644 --- a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto +++ b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto @@ -187,6 +187,21 @@ message XtcpFlatRecord { // destination IP is not in the feed set. string inet_diag_msg_socket_dest_network_owner = 1018; + // Destination endpoint locality, classified from the socket's own network + // namespace's local addresses + routing table (discovered via rtnetlink, + // see pkg/localnet). Populated by the opt-in locality enricher BEFORE the + // ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, + // so dest_asn (1011) / dest_network_owner (1018) stay empty for them. + // UNSPECIFIED when locality enrichment is disabled or the namespace has no + // snapshot yet. + enum Locality { + LOCALITY_UNSPECIFIED = 0; + LOCALITY_SELF = 1; // one of this host/namespace's own addresses (or loopback) + LOCALITY_LOCAL_SUBNET = 2; // on a directly-connected subnet (one L2 hop, no gateway) + LOCALITY_REMOTE = 3; // reached via a gateway (falls through to ASN lookup) + }; + Locality inet_diag_msg_socket_dest_locality = 1019; + // might want to put more here // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql index 24b17df..f432357 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql @@ -117,6 +117,11 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_dest_network_owner LowCardinality(String), + inet_diag_msg_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'connected_subnet' = 2, + 'remote' = 3 + ), inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql index b2fb4b1..ef5d9c5 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql @@ -112,6 +112,11 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), inet_diag_msg_socket_dest_network_owner LowCardinality(String), + inet_diag_msg_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'connected_subnet' = 2, + 'remote' = 3 + ), inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), diff --git a/docs/locality-enrichment.md b/docs/locality-enrichment.md new file mode 100644 index 0000000..5b94ba3 --- /dev/null +++ b/docs/locality-enrichment.md @@ -0,0 +1,239 @@ +# Destination locality enrichment via native rtnetlink discovery + +## Context and goal + +xtcp2 builds one `XtcpFlatRecord` per TCP socket on a hot path and enriches it +in place (container, LLDP/NIC, and — added just before this work — IP→ASN / +network-owner; see [ipfeed-asn-enrichment.md](ipfeed-asn-enrichment.md)). Until +now every destination IP fell straight through to the ipfeed IP→ASN lookup +(`pkg/xtcp/enrich.go`, the `x.asnIndex.Lookup` block). That is both wasteful and +wrong for traffic that never leaves the machine or its directly-connected +subnets: a socket whose destination is one of the host's own addresses, or an +address on a directly-attached subnet, should be labelled as such — not looked +up against an internet ASN feed that will never contain it. + +This work classifies each socket's **destination** endpoint, in the socket's own +network namespace, *before* the ASN lookup: + +1. destination is a **local/self address** of that namespace → `LOCALITY_SELF`; +2. destination is on a **directly-connected subnet** (a scope-link route with no + gateway) → `LOCALITY_LOCAL_SUBNET`; +3. otherwise → `LOCALITY_REMOTE`, and *only then* fall through to the existing + IP→ASN / network-owner enrichment. + +The result is stored in the new field +`inet_diag_msg_socket_dest_locality` (1019). Self and connected-subnet +destinations are tagged and skip the ASN feed, so `dest_asn` (1011) / +`dest_network_owner` (1018) stay empty for them — which is correct, since those +feeds only describe the public internet. + +### Why per-namespace + +xtcp2 already enters each container's network namespace to open its inet_diag +socket. A container's self-IP is not the host's, and each netns has its own +addresses and routing table, so locality **must** be evaluated in the socket's +own namespace. Classifying against the host's addresses would mislabel +container-local traffic. This is the correct behaviour for RunPod's +container/GPU hosts, where most namespaces are per-pod. Source-endpoint locality +is out of scope (mirrors the existing dest-only ASN enrichment). + +## Why native rtnetlink (no new dependency) + +The obvious library, `github.com/vishvananda/netlink`, is deliberately **not** +added. xtcp2 already opens `NETLINK_ROUTE` sockets and parses netlink messages +by hand via `golang.org/x/sys/unix` (see `pkg/nsdiscover/nsid.go` and the whole +`pkg/xtcpnl` message-parsing + testdata harness). Adding a second, heavier +netlink stack for three DUMP message types would duplicate machinery we already +own and test. Instead we taught `pkg/xtcpnl` to **send** the rtnetlink DUMP +requests (`RTM_GETLINK` / `RTM_GETADDR` / `RTM_GETROUTE`) and **parse** the +replies itself, reusing the existing `RTAttr`, `NlMsgHdr`, alignment and +testdata primitives. The vishvananda clone at `/home/das/Downloads/netlink` was +used for wire-format reference only. + +All kernel UAPI enum values (`RTM_*`, `IFA_*`, `RTA_*`, `RTN_*`, `RT_SCOPE_*`, +`RT_TABLE_*`, `NLM_*`, `NLMSG_*`, `IFLA_IFNAME`) are exported by +`golang.org/x/sys/unix`, so no constants are re-declared. + +## rtnetlink DUMP reference + +A DUMP request is one 16-byte `nlmsghdr` with `NLM_F_REQUEST|NLM_F_DUMP`, +followed by a family header: + +| Request | Family header | Size | Reply message | +|----------------|---------------|------|---------------| +| `RTM_GETLINK` | `ifinfomsg` | 16 B | `RTM_NEWLINK` | +| `RTM_GETADDR` | `ifaddrmsg` | 8 B | `RTM_NEWADDR` | +| `RTM_GETROUTE` | `rtmsg` | 12 B | `RTM_NEWROUTE` | + +The kernel replies with a **multipart** stream of `RTM_NEW*` messages terminated +by `NLMSG_DONE`; `NLMSG_ERROR` carries a negative errno in its first int32 +(zero = ACK), and `NLMSG_NOOP` is skipped. Each `RTM_NEW*` body is its family +header followed by 4-byte-aligned `RTAttr` TLVs. All header integers are +little-endian on the amd64/arm64 targets; address payloads are raw +network-order bytes (4 for IPv4, 16 for IPv6). + +`DumpRtnetlink` drives one request → multi-recv loop, invoking a callback for +each `RTM_NEW*` body; the recv buffer is reused, so parsers copy any bytes they +retain. + +### The classification decision rule + +Applied in `pkg/localnet.BuildSnapshot`, from one namespace's parsed +`AddrInfo` + `RouteInfo`: + +- **Self** = every interface address (`IFA_LOCAL`, falling back to + `IFA_ADDRESS`) **plus** every `RTN_LOCAL` route destination. The route dump is + issued with `AF_UNSPEC`, which returns *all* tables (main + local), so the + local table's `RTN_LOCAL` host entries (scope host) are included and reinforce + the self set. +- **Connected subnet** = a route that is `RTN_UNICAST` **and** + `RT_SCOPE_LINK` **and** has **no** `RTA_GATEWAY` **and** carries a destination + prefix. That is exactly "reachable in one L2 hop, no next-hop router". A `/0` + such route is defensively dropped so it cannot swallow everything. +- **Remote** = everything else (reached via a gateway, or unknown). + +## Snapshot data structure and hot-path contract + +`pkg/localnet` mirrors `pkg/ipasn`'s contract: an immutable snapshot built off +the hot path, published atomically, read lock/alloc-free. + +- A `Snapshot` holds a single `gaissmai/bart` longest-prefix-match trie of + `netip.Prefix → Locality`. Self addresses are inserted as host prefixes + (`/32`, `/128`); connected subnets as their network prefix. Because it is one + LPM trie, a self host address **wins** over its containing subnet in a single + `Lookup` — no ordering logic needed. +- `Classify(addr)` unmaps IPv4-in-IPv6, short-circuits loopback / unspecified to + `LOCALITY_SELF`, then does one `Lookup`, defaulting to `LOCALITY_REMOTE`. It is + pure and allocation-free (measured 0 allocs/op, ~14–28 ns/op). +- The `localnet.Locality` values match the `XtcpFlatRecord.Locality` enum, so a + classification stores directly into the record via a plain cast. + +### Hot-path wiring (`pkg/xtcp`) + +`applyEnrichment` computes the destination `netip.Addr` once (via the existing +alloc-free `destAddr` helper), classifies it against the per-namespace snapshot, +stores the locality, and gates the ASN lookup on `REMOTE`. `remote` defaults to +`true`, so when locality is disabled (nil map) or no snapshot exists for the +namespace, the ASN block runs exactly as before — a strict superset of previous +behaviour. + +```go +if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok { + remote := true + if m := x.localityByInode.Load(); m != nil { + if snap := (*m)[r.NetnsInode]; snap != nil { + loc := snap.Classify(addr) + r.InetDiagMsgSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(loc) + remote = loc == localnet.LocalityRemote + } + } + if remote && x.asnIndex != nil { + // ... existing dest-ASN / network-owner lookup ... + } +} +``` + +### Discovery and refresh (`pkg/xtcp/enrich_locality.go`) + +Discovery runs on the **single-owner reconcile path** (`discoverNamespaces`, +under `reconcileMu`), which already has each namespace's full identity (a live +pid *and*, for bind-mounted namespaces, the mount path). This deliberately keeps +the delicate `netNamespaceInstance` / socket-lifecycle code untouched and avoids +any per-namespace route-socket registry or fd-reuse races. + +Each namespace is dumped in a **dedicated OS thread that is never unlocked**: +after `setns` the thread is netns-tainted, so returning without +`runtime.UnlockOSThread` makes the Go runtime terminate it rather than recycle +it — the same safety property `netNamespaceInstance` relies on to avoid the +tainted-M thread-exhaustion regression. The route socket is opened, bound, given +an `SO_RCVTIMEO`, and dumped (links, addresses, routes) entirely within that +thread; `BuildSnapshot` produces the immutable result and the map is published +with `atomic.Store`. + +Refresh is throttled by `locality_refresh_interval`: a **full** pass +re-discovers every namespace; intervening passes only dump namespaces that +appeared since the last snapshot (a new container is classified promptly without +re-dumping everything). A namespace whose dump fails keeps its previous +snapshot rather than dropping to unclassified. `interval <= 0` means discover +each namespace once and never refresh it (new namespaces are still picked up). + +## Configuration (`proto/xtcp_config/v1`) + +- `enrich_locality_enable` (242) — opt-in gate, off by default. +- `locality_refresh_interval` (243, `google.protobuf.Duration`) — refresh + cadence; `0` = discover-once. + +Settable via config file / gRPC config service (matches the ASN toggle, which is +also not wired to CLI flags today). + +## Record + downstream schema plumbing + +Following `inet_diag_msg_socket_dest_network_owner` (1018) as the checklist: + +- **Flat-record proto**: nested `Locality` enum + (`UNSPECIFIED`/`SELF`/`LOCAL_SUBNET`/`REMOTE`) + field + `inet_diag_msg_socket_dest_locality` (1019). Regenerated into `gen/`. +- **Parquet**: `int32` column (enums are stored numerically, like + `congestion_algorithm_enum`) in `destinations_s3parquet_schema.go`, copied in + `destinations_s3parquet.go`. +- **ClickHouse**: an `Enum('unspecified'=0,'self'=1,'connected_subnet'=2, + 'remote'=3)` column in the MergeTree table and the Kafka-engine table (the + MV is `SELECT *`, so it needs no change). ClickHouse maps protobuf enums by + numeric value, so the label strings are chosen for readability. +- **recordfmt**: a `LocalityName` humanizer (trims the `LOCALITY_` prefix) and a + humanized column case, mirroring `CongestionAlgorithmName`. + +## Testing and testdata + +Every unit test is table-driven with a `description` and an expected-outcome +column, covering positive, negative, boundary and corner cases (the repo's +table-driven standard), matching `pkg/xtcpnl` conventions. + +- **`pkg/localnet`** — `TestClassify`, `TestClassifyInvalidAndNil`, + `TestBuildSnapshot`, `TestLocalityString`: self / connected-subnet / remote + hits (IPv4 + IPv6); gateway and universe-scope routes that must *not* become + subnets; `/32`, `/128`, `/0`, more-specific-wins boundaries; loopback / + unspecified / IPv4-mapped / malformed-attr corners. Plus a race test + (concurrent `Classify` during atomic `Store`, run under `-race`) and a + `Classify` benchmark asserting the alloc-free contract. +- **`pkg/xtcpnl`** — deserializer tests for `ifaddrmsg` / `rtmsg` / `ifinfomsg` + (manual vs reflection), parser tests for `ParseNewAddr` / `ParseNewRoute` / + `ParseNewLink`, request-builder tests, `walkRTAttrs` and `netlinkErr` tests, + a live `DumpRtnetlink` integration test (skipped when netlink is unavailable), + and fuzz targets that assert the parsers never panic on arbitrary bytes. + +### Capturing real netlink fixtures with nlmon + +To capture real wire bytes for saved fixtures (per target kernel; the +`testdata//` layout, e.g. `7_1_8/`), `nlmon0` mirrors netlink so tcpdump +records both the request and the multipart replies: + +```sh +sudo modprobe nlmon +lsmod | grep nlmon +sudo ip link add nlmon0 type nlmon +sudo ip link set dev nlmon0 up +sudo tcpdump -i nlmon0 -w netlink.pcap # terminal 1 +# terminal 2: generate the RTM_GET* dumps we parse +ip addr show ; ip -6 addr show # RTM_GETADDR +ip route show table all # RTM_GETROUTE (main + local) +ip link show # RTM_GETLINK +# stop tcpdump +sudo chown das:das *.pcap +``` + +Save the `ip addr` / `ip route` / `ip link` output as an `_info` sidecar (the +source of truth the expected structs are derived from), and capture at least one +host-ns and one container-ns example so the per-namespace path has real +fixtures. Slice per-message-type fixtures out of `netlink.pcap` with a generator +test (modelled on `xtcpnl_extract_7_0_3_fixtures_test.go`, using +`PcapNetlinkOffsetCst`) so fixtures are reproducible and `git status` stays +clean. + +## Phasing / out of scope + +- **Source-endpoint** locality (destination only, per decision). +- Reconciling `pkg/nicinfo`'s `/proc`-based local-network discovery with this + netlink path (they coexist; unifying them is separate). +- Non-default routing policy (VRFs, policy routing beyond main + local tables). +- Pushing, PRs, or image publishing. diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc index 32dbd37..179b545 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc @@ -1515,12 +1515,12 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const { PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_._has_bits_), 0, // no _extensions_ - 241, 248, // max_field_number, fast_idx_mask + 243, 248, // max_field_number, fast_idx_mask offsetof(ParseTableT_, field_lookup_table), 3757571583, // skipmap offsetof(ParseTableT_, field_entries), - 69, // num_field_entries - 8, // num_aux_entries + 71, // num_field_entries + 9, // num_aux_entries offsetof(ParseTableT_, aux_entries), class_data, nullptr, // post_loop_handler @@ -1626,7 +1626,7 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const 65464, 40, 58366, 44, 8207, 48, - 64512, 59, + 61440, 59, 65535, 65535 }}, {{ // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { @@ -1652,11 +1652,11 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.capture_path_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.marshal_to_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_rows_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { @@ -1674,11 +1674,11 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string dest = 130 [json_name = "dest", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_), _Internal::kHasBitsOffset + 23, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_region_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { @@ -1686,9 +1686,9 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_app_name_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string topic = 140 [json_name = "topic", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.topic_), _Internal::kHasBitsOffset + 25, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { @@ -1698,7 +1698,7 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_), _Internal::kHasBitsOffset + 38, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string label = 170 [json_name = "label", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.label_), _Internal::kHasBitsOffset + 28, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string tag = 180 [json_name = "tag", (.buf.validate.field) = { @@ -1708,65 +1708,69 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.hostname_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.daemon_version_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_), _Internal::kHasBitsOffset + 39, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.csv_columns_), _Internal::kHasBitsOffset + 33, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_interval_), _Internal::kHasBitsOffset + 40, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_backoff_cap_), _Internal::kHasBitsOffset + 41, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_), _Internal::kHasBitsOffset + 42, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_container_enable_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_container_enable_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.docker_socket_path_), _Internal::kHasBitsOffset + 34, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_lldp_enable_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_lldp_enable_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_socket_path_), _Internal::kHasBitsOffset + 35, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_version_hint_), _Internal::kHasBitsOffset + 36, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_nic_enable_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_nic_enable_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_interfaces_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, // bool populate_nsid = 238 [json_name = "populateNsid"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_db_path_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_refresh_interval_), _Internal::kHasBitsOffset + 43, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_locality_enable_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.locality_refresh_interval_), _Internal::kHasBitsOffset + 44, 8, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ #ifndef PROTOBUF_MESSAGE_GLOBALS @@ -1809,6 +1813,11 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const #else {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, #endif + #ifndef PROTOBUF_MESSAGE_GLOBALS + {::_pbi::TcParser::GetTable<::google::protobuf::Duration>()}, + #else + {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, + #endif }}, {{ "\31\0\0\0\0\0\0\0\0\0\0\14\0\12\0\0\21\13\11\11\15\15\4\0\11\0\0\15\22\0\0\5\17\20\0\0\5\3\10\10\0\0\0\16\0\0\0\0\0\13\0\0\0\0\0\0\0\0\0\22\0\21\22\0\0\21\0\0\13\0\0\0" @@ -1946,6 +1955,7 @@ inline constexpr XtcpConfig::Impl_::Impl_( s3_upload_backoff_cap_{nullptr}, reconcile_frequency_{nullptr}, asn_refresh_interval_{nullptr}, + locality_refresh_interval_{nullptr}, modulus_{::uint64_t{0u}}, envelope_flush_threshold_bytes_{0u}, s3_parquet_flush_threshold_bytes_{0u}, @@ -1970,7 +1980,8 @@ inline constexpr XtcpConfig::Impl_::Impl_( enrich_nic_enable_{false}, populate_nsid_{false}, uplink_count_{0u}, - enrich_asn_enable_{false} {} + enrich_asn_enable_{false}, + enrich_locality_enable_{false} {} template constexpr XtcpConfig::XtcpConfig(::_pbi::ConstantInitialized, @@ -3025,7 +3036,7 @@ const ::uint32_t 0, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_._has_bits_), - 72, // hasbit index offset + 74, // hasbit index offset PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.nl_timeout_milliseconds_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_frequency_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_timeout_), @@ -3095,6 +3106,8 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_asn_enable_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.asn_db_path_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.asn_refresh_interval_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_locality_enable_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.locality_refresh_interval_), 7, 5, 6, @@ -3106,9 +3119,9 @@ const ::uint32_t 13, 14, 18, - 44, - 19, 45, + 19, + 46, 15, 20, 0, @@ -3116,54 +3129,56 @@ const ::uint32_t 1, 22, 2, - 46, + 47, 3, - 52, + 53, 24, 4, - 47, 48, + 49, 23, 16, 25, 26, 27, 38, - 49, + 50, 28, 29, 30, 31, 32, - 53, - 50, - 51, - 56, - 39, 54, + 51, + 52, 57, + 39, + 55, 58, - 33, 59, - 40, + 33, 60, + 40, 61, 62, + 63, 41, 42, - 55, - 63, - 34, + 56, 64, + 34, + 65, 35, 36, - 65, - 67, - 17, 66, 68, + 17, + 67, + 69, 37, 43, + 70, + 44, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse, _impl_._has_bits_), 5, // hasbit index offset @@ -3195,8 +3210,8 @@ static const ::_pbi::MigrationSchema {56, sizeof(::xtcp_config::v1::SetEnvelopeFlushRequest)}, {63, sizeof(::xtcp_config::v1::SetEnvelopeFlushResponse)}, {68, sizeof(::xtcp_config::v1::XtcpConfig)}, - {209, sizeof(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse)}, - {216, sizeof(::xtcp_config::v1::EnabledDeserializers)}, + {213, sizeof(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse)}, + {220, sizeof(::xtcp_config::v1::EnabledDeserializers)}, }; static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const file_message_globals[] = { @@ -3268,7 +3283,7 @@ const char descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto[ " 0 || this.envelope_flush_threshold_rows" " > 0\"N\n\030SetEnvelopeFlushResponse\0222\n\006conf" "ig\030\001 \001(\0132\032.xtcp_config.v1.XtcpConfigR\006co" - "nfig\"\237\037\n\nXtcpConfig\022F\n\027nl_timeout_millis" + "nfig\"\256 \n\nXtcpConfig\022F\n\027nl_timeout_millis" "econds\030\n \001(\004B\016\272H\0132\006\030\240\215\006(\000\310\001\001R\025nlTimeoutM" "illiseconds\022S\n\016poll_frequency\030\024 \001(\0132\031.go" "ogle.protobuf.DurationB\021\272H\016\252\001\010\"\004\010\200\365$*\000\310\001" @@ -3365,40 +3380,44 @@ const char descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto[ "snEnable\022)\n\013asn_db_path\030\360\001 \001(\tB\010\272H\005r\003\030\377\001" "R\tasnDbPath\022L\n\024asn_refresh_interval\030\361\001 \001" "(\0132\031.google.protobuf.DurationR\022asnRefres" - "hInterval:s\272Hp\032n\n\017XtcpConfig.poll\0222Poll " - "timeout must be less than poll poll_freq" - "uency\032\'this.poll_frequency > this.poll_t" - "imeout\"\237\001\n\024EnabledDeserializers\022K\n\007enabl" - "ed\030\001 \003(\01321.xtcp_config.v1.EnabledDeseria" - "lizers.EnabledEntryR\007enabled\032:\n\014EnabledE" - "ntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\010R\005v" - "alue:\0028\0012\207\007\n\rConfigService\022]\n\003Get\022\032.xtcp" - "_config.v1.GetRequest\032\033.xtcp_config.v1.G" - "etResponse\"\035\202\323\344\223\002\027\032\022/ConfigService/Get:\001" - "*\022]\n\003Set\022\032.xtcp_config.v1.SetRequest\032\033.x" - "tcp_config.v1.SetResponse\"\035\202\323\344\223\002\027\032\022/Conf" - "igService/Set:\001*\022\221\001\n\020SetPollFrequency\022\'." - "xtcp_config.v1.SetPollFrequencyRequest\032(" - ".xtcp_config.v1.SetPollFrequencyResponse" - "\"*\202\323\344\223\002$\032\037/ConfigService/SetPollFrequenc" - "y:\001*\022}\n\013TriggerPoll\022\".xtcp_config.v1.Tri" - "ggerPollRequest\032#.xtcp_config.v1.Trigger" - "PollResponse\"%\202\323\344\223\002\037\032\032/ConfigService/Tri" - "ggerPoll:\001*\022\221\001\n\020TriggerPollBurst\022\'.xtcp_" - "config.v1.TriggerPollBurstRequest\032(.xtcp" - "_config.v1.TriggerPollBurstResponse\"*\202\323\344" - "\223\002$\032\037/ConfigService/TriggerPollBurst:\001*\022" - "}\n\013SetS3Upload\022\".xtcp_config.v1.SetS3Upl" - "oadRequest\032#.xtcp_config.v1.SetS3UploadR" - "esponse\"%\202\323\344\223\002\037\032\032/ConfigService/SetS3Upl" - "oad:\001*\022\221\001\n\020SetEnvelopeFlush\022\'.xtcp_confi" - "g.v1.SetEnvelopeFlushRequest\032(.xtcp_conf" - "ig.v1.SetEnvelopeFlushResponse\"*\202\323\344\223\002$\032\037" - "/ConfigService/SetEnvelopeFlush:\001*B\220\001\n\022c" - "om.xtcp_config.v1B\017XtcpConfigProtoP\001Z\024./" - "gen/go/xtcp_config\242\002\003XXX\252\002\rXtcpConfig.V1" - "\312\002\rXtcpConfig\\V1\342\002\031XtcpConfig\\V1\\GPBMeta" - "data\352\002\016XtcpConfig::V1b\006proto3" + "hInterval\0225\n\026enrich_locality_enable\030\362\001 \001" + "(\010R\024enrichLocalityEnable\022V\n\031locality_ref" + "resh_interval\030\363\001 \001(\0132\031.google.protobuf.D" + "urationR\027localityRefreshInterval:s\272Hp\032n\n" + "\017XtcpConfig.poll\0222Poll timeout must be l" + "ess than poll poll_frequency\032\'this.poll_" + "frequency > this.poll_timeout\"\237\001\n\024Enable" + "dDeserializers\022K\n\007enabled\030\001 \003(\01321.xtcp_c" + "onfig.v1.EnabledDeserializers.EnabledEnt" + "ryR\007enabled\032:\n\014EnabledEntry\022\020\n\003key\030\001 \001(\t" + "R\003key\022\024\n\005value\030\002 \001(\010R\005value:\0028\0012\207\007\n\rConf" + "igService\022]\n\003Get\022\032.xtcp_config.v1.GetReq" + "uest\032\033.xtcp_config.v1.GetResponse\"\035\202\323\344\223\002" + "\027\032\022/ConfigService/Get:\001*\022]\n\003Set\022\032.xtcp_c" + "onfig.v1.SetRequest\032\033.xtcp_config.v1.Set" + "Response\"\035\202\323\344\223\002\027\032\022/ConfigService/Set:\001*\022" + "\221\001\n\020SetPollFrequency\022\'.xtcp_config.v1.Se" + "tPollFrequencyRequest\032(.xtcp_config.v1.S" + "etPollFrequencyResponse\"*\202\323\344\223\002$\032\037/Config" + "Service/SetPollFrequency:\001*\022}\n\013TriggerPo" + "ll\022\".xtcp_config.v1.TriggerPollRequest\032#" + ".xtcp_config.v1.TriggerPollResponse\"%\202\323\344" + "\223\002\037\032\032/ConfigService/TriggerPoll:\001*\022\221\001\n\020T" + "riggerPollBurst\022\'.xtcp_config.v1.Trigger" + "PollBurstRequest\032(.xtcp_config.v1.Trigge" + "rPollBurstResponse\"*\202\323\344\223\002$\032\037/ConfigServi" + "ce/TriggerPollBurst:\001*\022}\n\013SetS3Upload\022\"." + "xtcp_config.v1.SetS3UploadRequest\032#.xtcp" + "_config.v1.SetS3UploadResponse\"%\202\323\344\223\002\037\032\032" + "/ConfigService/SetS3Upload:\001*\022\221\001\n\020SetEnv" + "elopeFlush\022\'.xtcp_config.v1.SetEnvelopeF" + "lushRequest\032(.xtcp_config.v1.SetEnvelope" + "FlushResponse\"*\202\323\344\223\002$\032\037/ConfigService/Se" + "tEnvelopeFlush:\001*B\220\001\n\022com.xtcp_config.v1" + "B\017XtcpConfigProtoP\001Z\024./gen/go/xtcp_confi" + "g\242\002\003XXX\252\002\rXtcpConfig.V1\312\002\rXtcpConfig\\V1\342" + "\002\031XtcpConfig\\V1\\GPBMetadata\352\002\016XtcpConfig" + "::V1b\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_deps[3] = { @@ -3410,7 +3429,7 @@ static ::absl::once_flag descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2ep PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto = { false, false, - 7149, + 7292, descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto, "xtcp_config/v1/xtcp_config.proto", &descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_once, @@ -6165,6 +6184,11 @@ void XtcpConfig::clear_asn_refresh_interval() { if (_impl_.asn_refresh_interval_ != nullptr) _impl_.asn_refresh_interval_->Clear(); ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } +void XtcpConfig::clear_locality_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.locality_refresh_interval_ != nullptr) _impl_.locality_refresh_interval_->Clear(); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); +} XtcpConfig::XtcpConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) : ::google::protobuf::Message(arena, XtcpConfig_get_class_data()) { @@ -6260,13 +6284,16 @@ XtcpConfig::XtcpConfig( _impl_.asn_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00000800U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.asn_refresh_interval_) : nullptr; + _impl_.locality_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00001000U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.locality_refresh_interval_) + : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, modulus_), reinterpret_cast(&from._impl_) + offsetof(Impl_, modulus_), - offsetof(Impl_, enrich_asn_enable_) - + offsetof(Impl_, enrich_locality_enable_) - offsetof(Impl_, modulus_) + - sizeof(Impl_::enrich_asn_enable_)); + sizeof(Impl_::enrich_locality_enable_)); // @@protoc_insertion_point(copy_constructor:xtcp_config.v1.XtcpConfig) } @@ -6316,9 +6343,9 @@ inline void XtcpConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, kafka_produce_timeout_), 0, - offsetof(Impl_, enrich_asn_enable_) - + offsetof(Impl_, enrich_locality_enable_) - offsetof(Impl_, kafka_produce_timeout_) + - sizeof(Impl_::enrich_asn_enable_)); + sizeof(Impl_::enrich_locality_enable_)); } XtcpConfig::~XtcpConfig() { // @@protoc_insertion_point(destructor:xtcp_config.v1.XtcpConfig) @@ -6364,6 +6391,7 @@ inline void XtcpConfig::SharedDtor(MessageLite& self) { delete this_._impl_.s3_upload_backoff_cap_; delete this_._impl_.reconcile_frequency_; delete this_._impl_.asn_refresh_interval_; + delete this_._impl_.locality_refresh_interval_; this_._impl_.~Impl_(); } @@ -6511,7 +6539,7 @@ PROTOBUF_NOINLINE void XtcpConfig::Clear() { _impl_.enabled_deserializers_->Clear(); } } - if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00001f00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { ABSL_DCHECK(_impl_.s3_flush_interval_ != nullptr); _impl_.s3_flush_interval_->Clear(); @@ -6528,27 +6556,31 @@ PROTOBUF_NOINLINE void XtcpConfig::Clear() { ABSL_DCHECK(_impl_.asn_refresh_interval_ != nullptr); _impl_.asn_refresh_interval_->Clear(); } + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + ABSL_DCHECK(_impl_.locality_refresh_interval_ != nullptr); + _impl_.locality_refresh_interval_->Clear(); + } } - if (BatchCheckHasBit(cached_has_bits, 0x0000f000U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000e000U)) { ::memset(&_impl_.modulus_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.pyroscope_sample_hz_) - - reinterpret_cast(&_impl_.modulus_)) + sizeof(_impl_.pyroscope_sample_hz_)); + reinterpret_cast(&_impl_.s3_parquet_flush_threshold_bytes_) - + reinterpret_cast(&_impl_.modulus_)) + sizeof(_impl_.s3_parquet_flush_threshold_bytes_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.pyroscope_upload_interval_sec_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.reconcile_before_poll_) - - reinterpret_cast(&_impl_.pyroscope_upload_interval_sec_)) + sizeof(_impl_.reconcile_before_poll_)); + ::memset(&_impl_.pyroscope_sample_hz_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.io_uring_) - + reinterpret_cast(&_impl_.pyroscope_sample_hz_)) + sizeof(_impl_.io_uring_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.grpc_port_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.enrich_container_enable_) - - reinterpret_cast(&_impl_.grpc_port_)) + sizeof(_impl_.enrich_container_enable_)); + ::memset(&_impl_.reconcile_before_poll_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.s3_upload_max_attempts_) - + reinterpret_cast(&_impl_.reconcile_before_poll_)) + sizeof(_impl_.s3_upload_max_attempts_)); } cached_has_bits = _impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { - ::memset(&_impl_.enrich_lldp_enable_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.enrich_asn_enable_) - - reinterpret_cast(&_impl_.enrich_lldp_enable_)) + sizeof(_impl_.enrich_asn_enable_)); + if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { + ::memset(&_impl_.enrich_container_enable_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.enrich_locality_enable_) - + reinterpret_cast(&_impl_.enrich_container_enable_)) + sizeof(_impl_.enrich_locality_enable_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); @@ -6671,7 +6703,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_modulus() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -6692,7 +6724,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_envelope_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6782,7 +6814,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6803,7 +6835,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_s3_skip_bucket_probe() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -6843,7 +6875,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_pyroscope_sample_hz() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6852,7 +6884,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_pyroscope_upload_interval_sec() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6900,7 +6932,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_debug_level() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6951,7 +6983,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_resolve_container_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -6960,7 +6992,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_ipv4_ttl() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6969,7 +7001,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_ipv6_hop_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -6988,7 +7020,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_grpc_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7004,7 +7036,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_io_uring() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7013,7 +7045,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_io_uring_recv_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7022,7 +7054,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_io_uring_cqe_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7041,7 +7073,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_poll_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7057,7 +7089,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_s3_flush_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7066,7 +7098,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7075,7 +7107,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_s3_upload_max_attempts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7098,7 +7130,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_reconcile_before_poll() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7106,8 +7138,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_container_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7115,6 +7148,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[1]; // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (!this_._internal_docker_socket_path().empty()) { @@ -7127,7 +7161,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[2]; // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_lldp_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7158,7 +7192,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[2]; // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_enrich_nic_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7167,7 +7201,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_uplink_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -7188,7 +7222,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[2]; // bool populate_nsid = 238 [json_name = "populateNsid"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_populate_nsid() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7197,7 +7231,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_enrich_asn_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( @@ -7223,6 +7257,24 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( stream); } + cached_has_bits = this_._impl_._has_bits_[2]; + // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (this_._internal_enrich_locality_enable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 242, this_._internal_enrich_locality_enable(), target); + } + } + + cached_has_bits = this_._impl_._has_bits_[1]; + // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 243, *this_._impl_.locality_refresh_interval_, this_._impl_.locality_refresh_interval_->GetCachedSize(), target, + stream); + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( @@ -7554,179 +7606,190 @@ ::size_t XtcpConfig::ByteSizeLong() const { total_size += 2 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.asn_refresh_interval_); } - // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { + // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; if (CheckHasBit(cached_has_bits, 0x00001000U)) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.locality_refresh_interval_); + } + // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_modulus() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_modulus()); } } // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_envelope_flush_threshold_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_envelope_flush_threshold_bytes()); } } // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_parquet_flush_threshold_bytes()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_pyroscope_sample_hz() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_pyroscope_sample_hz()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_pyroscope_upload_interval_sec() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_pyroscope_upload_interval_sec()); } } // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_debug_level() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_debug_level()); } } // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_ipv4_ttl() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_ipv4_ttl()); } } // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_ipv6_hop_limit() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_ipv6_hop_limit()); } } // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_s3_skip_bucket_probe() != 0) { total_size += 3; } } // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_resolve_container_id() != 0) { total_size += 3; } } // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_io_uring() != 0) { total_size += 3; } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_reconcile_before_poll() != 0) { total_size += 3; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_grpc_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_grpc_port()); } } // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_io_uring_recv_batch_size() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_io_uring_recv_batch_size()); } } // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_io_uring_cqe_batch_size() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_io_uring_cqe_batch_size()); } } // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_poll_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_poll_jitter_pct()); } } // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_s3_flush_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_flush_jitter_pct()); } } // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_flush_threshold_jitter_pct()); } } // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_s3_upload_max_attempts() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_s3_upload_max_attempts()); } } + } + cached_has_bits = this_._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_container_enable() != 0) { total_size += 3; } } - } - cached_has_bits = this_._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_lldp_enable() != 0) { total_size += 3; } } // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_enrich_nic_enable() != 0) { total_size += 3; } } // bool populate_nsid = 238 [json_name = "populateNsid"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_populate_nsid() != 0) { total_size += 3; } } // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_uplink_count() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink_count()); } } // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_enrich_asn_enable() != 0) { total_size += 3; } } + // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (this_._internal_enrich_locality_enable() != 0) { + total_size += 3; + } + } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); @@ -8103,137 +8166,150 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00001000U)) { + ABSL_DCHECK(from._impl_.locality_refresh_interval_ != nullptr); + if (_this->_impl_.locality_refresh_interval_ == nullptr) { + _this->_impl_.locality_refresh_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.locality_refresh_interval_); + } else { + _this->_impl_.locality_refresh_interval_->MergeFrom(*from._impl_.locality_refresh_interval_); + } + } + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_modulus() != 0) { _this->_impl_.modulus_ = from._impl_.modulus_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_envelope_flush_threshold_bytes() != 0) { _this->_impl_.envelope_flush_threshold_bytes_ = from._impl_.envelope_flush_threshold_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_s3_parquet_flush_threshold_bytes() != 0) { _this->_impl_.s3_parquet_flush_threshold_bytes_ = from._impl_.s3_parquet_flush_threshold_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_pyroscope_sample_hz() != 0) { _this->_impl_.pyroscope_sample_hz_ = from._impl_.pyroscope_sample_hz_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_pyroscope_upload_interval_sec() != 0) { _this->_impl_.pyroscope_upload_interval_sec_ = from._impl_.pyroscope_upload_interval_sec_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_debug_level() != 0) { _this->_impl_.debug_level_ = from._impl_.debug_level_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_ipv4_ttl() != 0) { _this->_impl_.ipv4_ttl_ = from._impl_.ipv4_ttl_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_ipv6_hop_limit() != 0) { _this->_impl_.ipv6_hop_limit_ = from._impl_.ipv6_hop_limit_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_s3_skip_bucket_probe() != 0) { _this->_impl_.s3_skip_bucket_probe_ = from._impl_.s3_skip_bucket_probe_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_resolve_container_id() != 0) { _this->_impl_.resolve_container_id_ = from._impl_.resolve_container_id_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_io_uring() != 0) { _this->_impl_.io_uring_ = from._impl_.io_uring_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_reconcile_before_poll() != 0) { _this->_impl_.reconcile_before_poll_ = from._impl_.reconcile_before_poll_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_grpc_port() != 0) { _this->_impl_.grpc_port_ = from._impl_.grpc_port_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_io_uring_recv_batch_size() != 0) { _this->_impl_.io_uring_recv_batch_size_ = from._impl_.io_uring_recv_batch_size_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_io_uring_cqe_batch_size() != 0) { _this->_impl_.io_uring_cqe_batch_size_ = from._impl_.io_uring_cqe_batch_size_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_poll_jitter_pct() != 0) { _this->_impl_.poll_jitter_pct_ = from._impl_.poll_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_s3_flush_jitter_pct() != 0) { _this->_impl_.s3_flush_jitter_pct_ = from._impl_.s3_flush_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_s3_flush_threshold_jitter_pct() != 0) { _this->_impl_.s3_flush_threshold_jitter_pct_ = from._impl_.s3_flush_threshold_jitter_pct_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_s3_upload_max_attempts() != 0) { _this->_impl_.s3_upload_max_attempts_ = from._impl_.s3_upload_max_attempts_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + } + cached_has_bits = from._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (from._internal_enrich_container_enable() != 0) { _this->_impl_.enrich_container_enable_ = from._impl_.enrich_container_enable_; } } - } - cached_has_bits = from._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_enrich_lldp_enable() != 0) { _this->_impl_.enrich_lldp_enable_ = from._impl_.enrich_lldp_enable_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_enrich_nic_enable() != 0) { _this->_impl_.enrich_nic_enable_ = from._impl_.enrich_nic_enable_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_populate_nsid() != 0) { _this->_impl_.populate_nsid_ = from._impl_.populate_nsid_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_uplink_count() != 0) { _this->_impl_.uplink_count_ = from._impl_.uplink_count_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_enrich_asn_enable() != 0) { _this->_impl_.enrich_asn_enable_ = from._impl_.enrich_asn_enable_; } } + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (from._internal_enrich_locality_enable() != 0) { + _this->_impl_.enrich_locality_enable_ = from._impl_.enrich_locality_enable_; + } + } } _this->_impl_._has_bits_.Or(from._impl_._has_bits_); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -8289,8 +8365,8 @@ void XtcpConfig::InternalSwap(XtcpConfig* PROTOBUF_RESTRICT PROTOBUF_NONNULL oth ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.lldpd_version_hint_, &other->_impl_.lldpd_version_hint_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.asn_db_path_, &other->_impl_.asn_db_path_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_) - + sizeof(XtcpConfig::_impl_.enrich_asn_enable_) + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_locality_enable_) + + sizeof(XtcpConfig::_impl_.enrich_locality_enable_) - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_)>( reinterpret_cast(&_impl_.kafka_produce_timeout_), reinterpret_cast(&other->_impl_.kafka_produce_timeout_)); diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h index 41cc4d8..43f4e56 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h @@ -2171,6 +2171,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: kS3UploadBackoffCapFieldNumber = 226, kReconcileFrequencyFieldNumber = 227, kAsnRefreshIntervalFieldNumber = 241, + kLocalityRefreshIntervalFieldNumber = 243, kModulusFieldNumber = 110, kEnvelopeFlushThresholdBytesFieldNumber = 122, kS3ParquetFlushThresholdBytesFieldNumber = 132, @@ -2196,6 +2197,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: kPopulateNsidFieldNumber = 238, kUplinkCountFieldNumber = 236, kEnrichAsnEnableFieldNumber = 239, + kEnrichLocalityEnableFieldNumber = 242, }; // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { void clear_s3_endpoint() ; @@ -2826,6 +2828,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: const ::google::protobuf::Duration& _internal_asn_refresh_interval() const; ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_asn_refresh_interval(); + public: + // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; + [[nodiscard]] bool has_locality_refresh_interval() + const; + void clear_locality_refresh_interval() ; + [[nodiscard]] const ::google::protobuf::Duration& locality_refresh_interval() const; + [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_locality_refresh_interval(); + ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_locality_refresh_interval(); + void set_allocated_locality_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_locality_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_locality_refresh_interval(); + + private: + const ::google::protobuf::Duration& _internal_locality_refresh_interval() const; + ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_locality_refresh_interval(); + public: // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { void clear_modulus() ; @@ -3076,13 +3094,23 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: bool _internal_enrich_asn_enable() const; void _internal_set_enrich_asn_enable(bool value); + public: + // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + void clear_enrich_locality_enable() ; + [[nodiscard]] bool enrich_locality_enable() const; + void set_enrich_locality_enable(bool value); + + private: + bool _internal_enrich_locality_enable() const; + void _internal_set_enrich_locality_enable(bool value); + public: // @@protoc_insertion_point(class_scope:xtcp_config.v1.XtcpConfig) private: class _Internal; using ParseTableT_ = - ::google::protobuf::internal::TcParseTable<5, 69, - 8, 402, + ::google::protobuf::internal::TcParseTable<5, 71, + 9, 402, 31>; static constexpr ParseTableT_ InternalGenerateParseTable_( const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data); @@ -3154,6 +3182,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NULLABLE s3_upload_backoff_cap_; ::google::protobuf::Duration* PROTOBUF_NULLABLE reconcile_frequency_; ::google::protobuf::Duration* PROTOBUF_NULLABLE asn_refresh_interval_; + ::google::protobuf::Duration* PROTOBUF_NULLABLE locality_refresh_interval_; ::uint64_t modulus_; ::uint32_t envelope_flush_threshold_bytes_; ::uint32_t s3_parquet_flush_threshold_bytes_; @@ -3179,6 +3208,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: bool populate_nsid_; ::uint32_t uplink_count_; bool enrich_asn_enable_; + bool enrich_locality_enable_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; @@ -6118,7 +6148,7 @@ inline void XtcpConfig::set_allocated_capture_path(::std::string* PROTOBUF_NULLA inline void XtcpConfig::clear_modulus() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.modulus_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); } inline ::uint64_t XtcpConfig::modulus() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.modulus) @@ -6126,7 +6156,7 @@ inline ::uint64_t XtcpConfig::modulus() const { } inline void XtcpConfig::set_modulus(::uint64_t value) { _internal_set_modulus(value); - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.modulus) } inline ::uint64_t XtcpConfig::_internal_modulus() const { @@ -6206,7 +6236,7 @@ inline void XtcpConfig::set_allocated_marshal_to(::std::string* PROTOBUF_NULLABL inline void XtcpConfig::clear_envelope_flush_threshold_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.envelope_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) @@ -6214,7 +6244,7 @@ inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { } inline void XtcpConfig::set_envelope_flush_threshold_bytes(::uint32_t value) { _internal_set_envelope_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00002000U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) } inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_bytes() const { @@ -6638,7 +6668,7 @@ inline void XtcpConfig::set_allocated_s3_secret_key(::std::string* PROTOBUF_NULL inline void XtcpConfig::clear_s3_parquet_flush_threshold_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_parquet_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) @@ -6646,7 +6676,7 @@ inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { } inline void XtcpConfig::set_s3_parquet_flush_threshold_bytes(::uint32_t value) { _internal_set_s3_parquet_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00004000U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) } inline ::uint32_t XtcpConfig::_internal_s3_parquet_flush_threshold_bytes() const { @@ -6726,7 +6756,7 @@ inline void XtcpConfig::set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE inline void XtcpConfig::clear_s3_skip_bucket_probe() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_skip_bucket_probe_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00100000U); + ClearHasBit(_impl_._has_bits_[1], 0x00200000U); } inline bool XtcpConfig::s3_skip_bucket_probe() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) @@ -6734,7 +6764,7 @@ inline bool XtcpConfig::s3_skip_bucket_probe() const { } inline void XtcpConfig::set_s3_skip_bucket_probe(bool value) { _internal_set_s3_skip_bucket_probe(value); - SetHasBit(_impl_._has_bits_[1], 0x00100000U); + SetHasBit(_impl_._has_bits_[1], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) } inline bool XtcpConfig::_internal_s3_skip_bucket_probe() const { @@ -6878,7 +6908,7 @@ inline void XtcpConfig::set_allocated_pyroscope_app_name(::std::string* PROTOBUF inline void XtcpConfig::clear_pyroscope_sample_hz() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pyroscope_sample_hz_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00008000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) @@ -6886,7 +6916,7 @@ inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { } inline void XtcpConfig::set_pyroscope_sample_hz(::uint32_t value) { _internal_set_pyroscope_sample_hz(value); - SetHasBit(_impl_._has_bits_[1], 0x00008000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) } inline ::uint32_t XtcpConfig::_internal_pyroscope_sample_hz() const { @@ -6902,7 +6932,7 @@ inline void XtcpConfig::_internal_set_pyroscope_sample_hz(::uint32_t value) { inline void XtcpConfig::clear_pyroscope_upload_interval_sec() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.pyroscope_upload_interval_sec_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00010000U); + ClearHasBit(_impl_._has_bits_[1], 0x00020000U); } inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) @@ -6910,7 +6940,7 @@ inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { } inline void XtcpConfig::set_pyroscope_upload_interval_sec(::uint32_t value) { _internal_set_pyroscope_upload_interval_sec(value); - SetHasBit(_impl_._has_bits_[1], 0x00010000U); + SetHasBit(_impl_._has_bits_[1], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) } inline ::uint32_t XtcpConfig::_internal_pyroscope_upload_interval_sec() const { @@ -7299,7 +7329,7 @@ inline void XtcpConfig::set_allocated_kafka_produce_timeout(::google::protobuf:: inline void XtcpConfig::clear_debug_level() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.debug_level_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00020000U); + ClearHasBit(_impl_._has_bits_[1], 0x00040000U); } inline ::uint32_t XtcpConfig::debug_level() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.debug_level) @@ -7307,7 +7337,7 @@ inline ::uint32_t XtcpConfig::debug_level() const { } inline void XtcpConfig::set_debug_level(::uint32_t value) { _internal_set_debug_level(value); - SetHasBit(_impl_._has_bits_[1], 0x00020000U); + SetHasBit(_impl_._has_bits_[1], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.debug_level) } inline ::uint32_t XtcpConfig::_internal_debug_level() const { @@ -7643,7 +7673,7 @@ inline void XtcpConfig::set_allocated_daemon_version(::std::string* PROTOBUF_NUL inline void XtcpConfig::clear_resolve_container_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.resolve_container_id_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00200000U); + ClearHasBit(_impl_._has_bits_[1], 0x00400000U); } inline bool XtcpConfig::resolve_container_id() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.resolve_container_id) @@ -7651,7 +7681,7 @@ inline bool XtcpConfig::resolve_container_id() const { } inline void XtcpConfig::set_resolve_container_id(bool value) { _internal_set_resolve_container_id(value); - SetHasBit(_impl_._has_bits_[1], 0x00200000U); + SetHasBit(_impl_._has_bits_[1], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.resolve_container_id) } inline bool XtcpConfig::_internal_resolve_container_id() const { @@ -7667,7 +7697,7 @@ inline void XtcpConfig::_internal_set_resolve_container_id(bool value) { inline void XtcpConfig::clear_ipv4_ttl() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipv4_ttl_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00040000U); + ClearHasBit(_impl_._has_bits_[1], 0x00080000U); } inline ::uint32_t XtcpConfig::ipv4_ttl() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv4_ttl) @@ -7675,7 +7705,7 @@ inline ::uint32_t XtcpConfig::ipv4_ttl() const { } inline void XtcpConfig::set_ipv4_ttl(::uint32_t value) { _internal_set_ipv4_ttl(value); - SetHasBit(_impl_._has_bits_[1], 0x00040000U); + SetHasBit(_impl_._has_bits_[1], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv4_ttl) } inline ::uint32_t XtcpConfig::_internal_ipv4_ttl() const { @@ -7691,7 +7721,7 @@ inline void XtcpConfig::_internal_set_ipv4_ttl(::uint32_t value) { inline void XtcpConfig::clear_ipv6_hop_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.ipv6_hop_limit_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00080000U); + ClearHasBit(_impl_._has_bits_[1], 0x00100000U); } inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) @@ -7699,7 +7729,7 @@ inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { } inline void XtcpConfig::set_ipv6_hop_limit(::uint32_t value) { _internal_set_ipv6_hop_limit(value); - SetHasBit(_impl_._has_bits_[1], 0x00080000U); + SetHasBit(_impl_._has_bits_[1], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) } inline ::uint32_t XtcpConfig::_internal_ipv6_hop_limit() const { @@ -7715,7 +7745,7 @@ inline void XtcpConfig::_internal_set_ipv6_hop_limit(::uint32_t value) { inline void XtcpConfig::clear_grpc_port() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.grpc_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x01000000U); + ClearHasBit(_impl_._has_bits_[1], 0x02000000U); } inline ::uint32_t XtcpConfig::grpc_port() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.grpc_port) @@ -7723,7 +7753,7 @@ inline ::uint32_t XtcpConfig::grpc_port() const { } inline void XtcpConfig::set_grpc_port(::uint32_t value) { _internal_set_grpc_port(value); - SetHasBit(_impl_._has_bits_[1], 0x01000000U); + SetHasBit(_impl_._has_bits_[1], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.grpc_port) } inline ::uint32_t XtcpConfig::_internal_grpc_port() const { @@ -7837,7 +7867,7 @@ inline void XtcpConfig::set_allocated_enabled_deserializers(::xtcp_config::v1::E inline void XtcpConfig::clear_io_uring() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00400000U); + ClearHasBit(_impl_._has_bits_[1], 0x00800000U); } inline bool XtcpConfig::io_uring() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring) @@ -7845,7 +7875,7 @@ inline bool XtcpConfig::io_uring() const { } inline void XtcpConfig::set_io_uring(bool value) { _internal_set_io_uring(value); - SetHasBit(_impl_._has_bits_[1], 0x00400000U); + SetHasBit(_impl_._has_bits_[1], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring) } inline bool XtcpConfig::_internal_io_uring() const { @@ -7861,7 +7891,7 @@ inline void XtcpConfig::_internal_set_io_uring(bool value) { inline void XtcpConfig::clear_io_uring_recv_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_recv_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x02000000U); + ClearHasBit(_impl_._has_bits_[1], 0x04000000U); } inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) @@ -7869,7 +7899,7 @@ inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { } inline void XtcpConfig::set_io_uring_recv_batch_size(::uint32_t value) { _internal_set_io_uring_recv_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x02000000U); + SetHasBit(_impl_._has_bits_[1], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) } inline ::uint32_t XtcpConfig::_internal_io_uring_recv_batch_size() const { @@ -7885,7 +7915,7 @@ inline void XtcpConfig::_internal_set_io_uring_recv_batch_size(::uint32_t value) inline void XtcpConfig::clear_io_uring_cqe_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.io_uring_cqe_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x04000000U); + ClearHasBit(_impl_._has_bits_[1], 0x08000000U); } inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) @@ -7893,7 +7923,7 @@ inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { } inline void XtcpConfig::set_io_uring_cqe_batch_size(::uint32_t value) { _internal_set_io_uring_cqe_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x04000000U); + SetHasBit(_impl_._has_bits_[1], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) } inline ::uint32_t XtcpConfig::_internal_io_uring_cqe_batch_size() const { @@ -7973,7 +8003,7 @@ inline void XtcpConfig::set_allocated_csv_columns(::std::string* PROTOBUF_NULLAB inline void XtcpConfig::clear_poll_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.poll_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x08000000U); + ClearHasBit(_impl_._has_bits_[1], 0x10000000U); } inline ::uint32_t XtcpConfig::poll_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.poll_jitter_pct) @@ -7981,7 +8011,7 @@ inline ::uint32_t XtcpConfig::poll_jitter_pct() const { } inline void XtcpConfig::set_poll_jitter_pct(::uint32_t value) { _internal_set_poll_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x08000000U); + SetHasBit(_impl_._has_bits_[1], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.poll_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_poll_jitter_pct() const { @@ -8090,7 +8120,7 @@ inline void XtcpConfig::set_allocated_s3_flush_interval(::google::protobuf::Dura inline void XtcpConfig::clear_s3_flush_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_flush_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x10000000U); + ClearHasBit(_impl_._has_bits_[1], 0x20000000U); } inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) @@ -8098,7 +8128,7 @@ inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { } inline void XtcpConfig::set_s3_flush_jitter_pct(::uint32_t value) { _internal_set_s3_flush_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x10000000U); + SetHasBit(_impl_._has_bits_[1], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_s3_flush_jitter_pct() const { @@ -8114,7 +8144,7 @@ inline void XtcpConfig::_internal_set_s3_flush_jitter_pct(::uint32_t value) { inline void XtcpConfig::clear_s3_flush_threshold_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_flush_threshold_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x20000000U); + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); } inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) @@ -8122,7 +8152,7 @@ inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { } inline void XtcpConfig::set_s3_flush_threshold_jitter_pct(::uint32_t value) { _internal_set_s3_flush_threshold_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x20000000U); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) } inline ::uint32_t XtcpConfig::_internal_s3_flush_threshold_jitter_pct() const { @@ -8138,7 +8168,7 @@ inline void XtcpConfig::_internal_set_s3_flush_threshold_jitter_pct(::uint32_t v inline void XtcpConfig::clear_s3_upload_max_attempts() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.s3_upload_max_attempts_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) @@ -8146,7 +8176,7 @@ inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { } inline void XtcpConfig::set_s3_upload_max_attempts(::uint32_t value) { _internal_set_s3_upload_max_attempts(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) } inline ::uint32_t XtcpConfig::_internal_s3_upload_max_attempts() const { @@ -8348,7 +8378,7 @@ inline void XtcpConfig::set_allocated_reconcile_frequency(::google::protobuf::Du inline void XtcpConfig::clear_reconcile_before_poll() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.reconcile_before_poll_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00800000U); + ClearHasBit(_impl_._has_bits_[1], 0x01000000U); } inline bool XtcpConfig::reconcile_before_poll() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_before_poll) @@ -8356,7 +8386,7 @@ inline bool XtcpConfig::reconcile_before_poll() const { } inline void XtcpConfig::set_reconcile_before_poll(bool value) { _internal_set_reconcile_before_poll(value); - SetHasBit(_impl_._has_bits_[1], 0x00800000U); + SetHasBit(_impl_._has_bits_[1], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.reconcile_before_poll) } inline bool XtcpConfig::_internal_reconcile_before_poll() const { @@ -8372,7 +8402,7 @@ inline void XtcpConfig::_internal_set_reconcile_before_poll(bool value) { inline void XtcpConfig::clear_enrich_container_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_container_enable_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000001U); } inline bool XtcpConfig::enrich_container_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_container_enable) @@ -8380,7 +8410,7 @@ inline bool XtcpConfig::enrich_container_enable() const { } inline void XtcpConfig::set_enrich_container_enable(bool value) { _internal_set_enrich_container_enable(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_container_enable) } inline bool XtcpConfig::_internal_enrich_container_enable() const { @@ -8460,7 +8490,7 @@ inline void XtcpConfig::set_allocated_docker_socket_path(::std::string* PROTOBUF inline void XtcpConfig::clear_enrich_lldp_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_lldp_enable_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000001U); + ClearHasBit(_impl_._has_bits_[2], 0x00000002U); } inline bool XtcpConfig::enrich_lldp_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_lldp_enable) @@ -8468,7 +8498,7 @@ inline bool XtcpConfig::enrich_lldp_enable() const { } inline void XtcpConfig::set_enrich_lldp_enable(bool value) { _internal_set_enrich_lldp_enable(value); - SetHasBit(_impl_._has_bits_[2], 0x00000001U); + SetHasBit(_impl_._has_bits_[2], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_lldp_enable) } inline bool XtcpConfig::_internal_enrich_lldp_enable() const { @@ -8612,7 +8642,7 @@ inline void XtcpConfig::set_allocated_lldpd_version_hint(::std::string* PROTOBUF inline void XtcpConfig::clear_enrich_nic_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_nic_enable_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000002U); + ClearHasBit(_impl_._has_bits_[2], 0x00000004U); } inline bool XtcpConfig::enrich_nic_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_nic_enable) @@ -8620,7 +8650,7 @@ inline bool XtcpConfig::enrich_nic_enable() const { } inline void XtcpConfig::set_enrich_nic_enable(bool value) { _internal_set_enrich_nic_enable(value); - SetHasBit(_impl_._has_bits_[2], 0x00000002U); + SetHasBit(_impl_._has_bits_[2], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_nic_enable) } inline bool XtcpConfig::_internal_enrich_nic_enable() const { @@ -8636,7 +8666,7 @@ inline void XtcpConfig::_internal_set_enrich_nic_enable(bool value) { inline void XtcpConfig::clear_uplink_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink_count_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000008U); + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); } inline ::uint32_t XtcpConfig::uplink_count() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.uplink_count) @@ -8644,7 +8674,7 @@ inline ::uint32_t XtcpConfig::uplink_count() const { } inline void XtcpConfig::set_uplink_count(::uint32_t value) { _internal_set_uplink_count(value); - SetHasBit(_impl_._has_bits_[2], 0x00000008U); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.uplink_count) } inline ::uint32_t XtcpConfig::_internal_uplink_count() const { @@ -8732,7 +8762,7 @@ XtcpConfig::_internal_mutable_uplink_interfaces() { inline void XtcpConfig::clear_populate_nsid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.populate_nsid_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000004U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline bool XtcpConfig::populate_nsid() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.populate_nsid) @@ -8740,7 +8770,7 @@ inline bool XtcpConfig::populate_nsid() const { } inline void XtcpConfig::set_populate_nsid(bool value) { _internal_set_populate_nsid(value); - SetHasBit(_impl_._has_bits_[2], 0x00000004U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.populate_nsid) } inline bool XtcpConfig::_internal_populate_nsid() const { @@ -8756,7 +8786,7 @@ inline void XtcpConfig::_internal_set_populate_nsid(bool value) { inline void XtcpConfig::clear_enrich_asn_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_asn_enable_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000010U); + ClearHasBit(_impl_._has_bits_[2], 0x00000020U); } inline bool XtcpConfig::enrich_asn_enable() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_asn_enable) @@ -8764,7 +8794,7 @@ inline bool XtcpConfig::enrich_asn_enable() const { } inline void XtcpConfig::set_enrich_asn_enable(bool value) { _internal_set_enrich_asn_enable(value); - SetHasBit(_impl_._has_bits_[2], 0x00000010U); + SetHasBit(_impl_._has_bits_[2], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_asn_enable) } inline bool XtcpConfig::_internal_enrich_asn_enable() const { @@ -8933,6 +8963,123 @@ inline void XtcpConfig::set_allocated_asn_refresh_interval(::google::protobuf::D // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.asn_refresh_interval) } +// bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; +inline void XtcpConfig::clear_enrich_locality_enable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_locality_enable_ = false; + ClearHasBit(_impl_._has_bits_[2], 0x00000040U); +} +inline bool XtcpConfig::enrich_locality_enable() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enrich_locality_enable) + return _internal_enrich_locality_enable(); +} +inline void XtcpConfig::set_enrich_locality_enable(bool value) { + _internal_set_enrich_locality_enable(value); + SetHasBit(_impl_._has_bits_[2], 0x00000040U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.enrich_locality_enable) +} +inline bool XtcpConfig::_internal_enrich_locality_enable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.enrich_locality_enable_; +} +inline void XtcpConfig::_internal_set_enrich_locality_enable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_locality_enable_ = value; +} + +// .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; +inline bool XtcpConfig::has_locality_refresh_interval() const { + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U); + PROTOBUF_ASSUME(!value || _impl_.locality_refresh_interval_ != nullptr); + return value; +} +inline const ::google::protobuf::Duration& XtcpConfig::_internal_locality_refresh_interval() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Duration* p = _impl_.locality_refresh_interval_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); +} +inline const ::google::protobuf::Duration& XtcpConfig::locality_refresh_interval() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.locality_refresh_interval) + return _internal_locality_refresh_interval(); +} +inline void XtcpConfig::unsafe_arena_set_allocated_locality_refresh_interval( + ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locality_refresh_interval_); + } + _impl_.locality_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00001000U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.locality_refresh_interval) +} +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_locality_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ::google::protobuf::Duration* released = _impl_.locality_refresh_interval_; + _impl_.locality_refresh_interval_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_locality_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.locality_refresh_interval) + + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ::google::protobuf::Duration* temp = _impl_.locality_refresh_interval_; + _impl_.locality_refresh_interval_ = nullptr; + return temp; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_locality_refresh_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.locality_refresh_interval_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); + _impl_.locality_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(p); + } + return _impl_.locality_refresh_interval_; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_locality_refresh_interval() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00001000U); + ::google::protobuf::Duration* _msg = _internal_mutable_locality_refresh_interval(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.locality_refresh_interval) + return _msg; +} +inline void XtcpConfig::set_allocated_locality_refresh_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.locality_refresh_interval_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[1], 0x00001000U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + } + + _impl_.locality_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.locality_refresh_interval) +} + // ------------------------------------------------------------------- // ------------------------------------------------------------------- diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc index ee9e304..b890493 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc @@ -62,7 +62,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl offsetof(ParseTableT_, field_lookup_table), 535297532, // skipmap offsetof(ParseTableT_, field_entries), - 157, // num_field_entries + 158, // num_field_entries 0, // num_aux_entries offsetof(ParseTableT_, field_names), // no aux_entries class_data, @@ -177,36 +177,36 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl 65039, 38, 1001, 0, 7, 0, 43, - 65532, 59, - 65535, 61, - 65535, 61, - 65535, 61, - 65535, 61, - 65295, 61, + 65528, 59, + 65535, 62, + 65535, 62, + 65535, 62, + 65535, 62, + 65295, 62, 1201, 0, 7, - 15360, 65, - 0, 77, - 0, 93, - 0, 109, - 65534, 125, - 65535, 126, - 65511, 126, + 15360, 66, + 0, 78, + 0, 94, + 0, 110, + 65534, 126, + 65535, 127, + 65511, 127, 1401, 0, 1, - 65532, 128, + 65532, 129, 1501, 0, 1, - 65024, 130, + 65024, 131, 1600, 0, 1, - 65534, 139, + 65534, 140, 1701, 0, 1, - 65520, 140, + 65520, 141, 1801, 0, 1, - 65504, 144, + 65504, 145, 1901, 0, 1, - 65504, 149, + 65504, 150, 2001, 0, 1, - 65532, 154, + 65532, 155, 2103, 0, 1, - 65534, 156, + 65534, 157, 65535, 65535 }}, {{ // uint32 schema_version = 1 [json_name = "schemaVersion"]; @@ -331,202 +331,204 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_inode_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_locality_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_send_scale_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_send_scale_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_var_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_var_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_adv_mss_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_adv_mss_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pacing_rate_), _Internal::kHasBitsOffset + 100, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_max_pacing_rate_), _Internal::kHasBitsOffset + 101, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_), _Internal::kHasBitsOffset + 110, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_busy_time_), _Internal::kHasBitsOffset + 111, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_sent_), _Internal::kHasBitsOffset + 116, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_dsack_dups_), _Internal::kHasBitsOffset + 118, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_string_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_enum_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_enum_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.type_of_service_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.type_of_service_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.traffic_class_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.traffic_class_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.shutdown_state_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.shutdown_state_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_min_rtt_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_min_rtt_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 class_id = 2001 [json_name = "classId"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.class_id_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.class_id_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_), _Internal::kHasBitsOffset + 157, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 c_group = 2103 [json_name = "cGroup"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_), _Internal::kHasBitsOffset + 156, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, // no aux_entries {{ - "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\47\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\33\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\47\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\33\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "xtcp_flat_record.v1.XtcpFlatRecord" "daemon_version" "hostname" @@ -699,6 +701,7 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( inet_diag_msg_wqueue_{0u}, inet_diag_msg_uid_{0u}, inet_diag_msg_inode_{0u}, + inet_diag_msg_socket_dest_locality_{static_cast< ::xtcp_flat_record::v1::XtcpFlatRecord_Locality >(0)}, mem_info_rmem_{0u}, mem_info_wmem_{0u}, mem_info_fmem_{0u}, @@ -736,26 +739,26 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( tcp_info_reordering_{0u}, tcp_info_rcv_rtt_{0u}, tcp_info_rcv_space_{0u}, - tcp_info_total_retrans_{0u}, tcp_info_pacing_rate_{::uint64_t{0u}}, tcp_info_max_pacing_rate_{::uint64_t{0u}}, + tcp_info_total_retrans_{0u}, + tcp_info_segs_out_{0u}, tcp_info_bytes_acked_{::uint64_t{0u}}, tcp_info_bytes_received_{::uint64_t{0u}}, - tcp_info_segs_out_{0u}, tcp_info_segs_in_{0u}, tcp_info_not_sent_bytes_{0u}, tcp_info_min_rtt_{0u}, tcp_info_data_segs_in_{0u}, - tcp_info_data_segs_out_{0u}, tcp_info_delivery_rate_{::uint64_t{0u}}, tcp_info_busy_time_{::uint64_t{0u}}, + tcp_info_data_segs_out_{0u}, + tcp_info_delivered_{0u}, tcp_info_rwnd_limited_{::uint64_t{0u}}, tcp_info_sndbuf_limited_{::uint64_t{0u}}, - tcp_info_delivered_{0u}, - tcp_info_delivered_ce_{0u}, tcp_info_bytes_sent_{::uint64_t{0u}}, - tcp_info_bytes_retrans_{::uint64_t{0u}}, + tcp_info_delivered_ce_{0u}, tcp_info_dsack_dups_{0u}, + tcp_info_bytes_retrans_{::uint64_t{0u}}, tcp_info_reord_seen_{0u}, tcp_info_rcv_ooopack_{0u}, tcp_info_snd_wnd_{0u}, @@ -792,8 +795,8 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( bbr_info_pacing_gain_{0u}, bbr_info_cwnd_gain_{0u}, class_id_{0u}, - sock_opt_{0u}, - c_group_{::uint64_t{0u}} {} + c_group_{::uint64_t{0u}}, + sock_opt_{0u} {} template constexpr XtcpFlatRecord::XtcpFlatRecord(::_pbi::ConstantInitialized, @@ -1583,7 +1586,7 @@ const ::_pbi::ClassData* Envelope_get_class_data() { } // namespace v1 } // namespace xtcp_flat_record static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL - file_level_enum_descriptors_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto[1]; + file_level_enum_descriptors_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto[2]; static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto = nullptr; const ::uint32_t @@ -1596,7 +1599,7 @@ const ::uint32_t 0, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_._has_bits_), - 160, // hasbit index offset + 161, // hasbit index offset PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.schema_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.daemon_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.timestamp_ns_), @@ -1658,6 +1661,7 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_uid_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_inode_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_locality_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_rmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_wmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_fmem_), @@ -1853,26 +1857,26 @@ const ::uint32_t 97, 98, 99, + 102, 100, 101, - 102, - 103, 104, 105, + 103, 106, 107, 108, 109, + 112, 110, 111, - 112, - 113, 114, 115, - 116, + 113, 117, - 118, + 116, 119, + 118, 120, 121, 122, @@ -1880,8 +1884,8 @@ const ::uint32_t 124, 125, 126, - 41, 127, + 41, 128, 129, 130, @@ -1910,6 +1914,7 @@ const ::uint32_t 153, 154, 155, + 157, 156, 0x000, // bitmap 0x081, // bitmap @@ -1929,10 +1934,10 @@ static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::xtcp_flat_record::v1::Envelope)}, {5, sizeof(::xtcp_flat_record::v1::XtcpFlatRecord)}, - {322, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, - {323, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, - {328, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, - {329, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, + {324, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, + {325, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, + {330, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, + {331, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, }; static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const file_message_globals[] = { @@ -1948,7 +1953,7 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr "\n*xtcp_flat_record/v1/xtcp_flat_record.p" "roto\022\023xtcp_flat_record.v1\"A\n\010Envelope\0225\n" "\003row\030\n \003(\0132#.xtcp_flat_record.v1.XtcpFla" - "tRecordR\003row\"\343<\n\016XtcpFlatRecord\022%\n\016schem" + "tRecordR\003row\"\306>\n\016XtcpFlatRecord\022%\n\016schem" "a_version\030\001 \001(\rR\rschemaVersion\022%\n\016daemon" "_version\030\002 \001(\tR\rdaemonVersion\022!\n\014timesta" "mp_ns\030\n \001(\003R\013timestampNs\022\032\n\010hostname\030\024 \001" @@ -2022,150 +2027,156 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr " \001(\rR\016inetDiagMsgUid\022.\n\023inet_diag_msg_in" "ode\030\371\007 \001(\rR\020inetDiagMsgInode\022S\n\'inet_dia" "g_msg_socket_dest_network_owner\030\372\007 \001(\tR!" - "inetDiagMsgSocketDestNetworkOwner\022#\n\rmem" - "_info_rmem\030\315\010 \001(\rR\013memInfoRmem\022#\n\rmem_in" - "fo_wmem\030\316\010 \001(\rR\013memInfoWmem\022#\n\rmem_info_" - "fmem\030\317\010 \001(\rR\013memInfoFmem\022#\n\rmem_info_tme" - "m\030\320\010 \001(\rR\013memInfoTmem\022%\n\016tcp_info_state\030" - "\261\t \001(\rR\014tcpInfoState\022*\n\021tcp_info_ca_stat" - "e\030\262\t \001(\rR\016tcpInfoCaState\0221\n\024tcp_info_ret" - "ransmits\030\263\t \001(\rR\022tcpInfoRetransmits\022\'\n\017t" - "cp_info_probes\030\264\t \001(\rR\rtcpInfoProbes\022)\n\020" - "tcp_info_backoff\030\265\t \001(\rR\016tcpInfoBackoff\022" - ")\n\020tcp_info_options\030\266\t \001(\rR\016tcpInfoOptio" - "ns\022.\n\023tcp_info_send_scale\030\267\t \001(\rR\020tcpInf" - "oSendScale\022,\n\022tcp_info_rcv_scale\030\270\t \001(\rR" - "\017tcpInfoRcvScale\022J\n\"tcp_info_delivery_ra" - "te_app_limited\030\271\t \001(\rR\035tcpInfoDeliveryRa" - "teAppLimited\022F\n tcp_info_fast_open_clien" - "t_failed\030\272\t \001(\rR\033tcpInfoFastOpenClientFa" - "iled\022!\n\014tcp_info_rto\030\277\t \001(\rR\ntcpInfoRto\022" - "!\n\014tcp_info_ato\030\300\t \001(\rR\ntcpInfoAto\022(\n\020tc" - "p_info_snd_mss\030\301\t \001(\rR\rtcpInfoSndMss\022(\n\020" - "tcp_info_rcv_mss\030\302\t \001(\rR\rtcpInfoRcvMss\022)" - "\n\020tcp_info_unacked\030\303\t \001(\rR\016tcpInfoUnacke" - "d\022\'\n\017tcp_info_sacked\030\304\t \001(\rR\rtcpInfoSack" - "ed\022#\n\rtcp_info_lost\030\305\t \001(\rR\013tcpInfoLost\022" - ")\n\020tcp_info_retrans\030\306\t \001(\rR\016tcpInfoRetra" - "ns\022)\n\020tcp_info_fackets\030\307\t \001(\rR\016tcpInfoFa" - "ckets\0225\n\027tcp_info_last_data_sent\030\310\t \001(\rR" - "\023tcpInfoLastDataSent\0223\n\026tcp_info_last_ac" - "k_sent\030\311\t \001(\rR\022tcpInfoLastAckSent\0225\n\027tcp" - "_info_last_data_recv\030\312\t \001(\rR\023tcpInfoLast" - "DataRecv\0223\n\026tcp_info_last_ack_recv\030\313\t \001(" - "\rR\022tcpInfoLastAckRecv\022#\n\rtcp_info_pmtu\030\314" - "\t \001(\rR\013tcpInfoPmtu\0222\n\025tcp_info_rcv_ssthr" - "esh\030\315\t \001(\rR\022tcpInfoRcvSsthresh\022!\n\014tcp_in" - "fo_rtt\030\316\t \001(\rR\ntcpInfoRtt\022(\n\020tcp_info_rt" - "t_var\030\317\t \001(\rR\rtcpInfoRttVar\0222\n\025tcp_info_" - "snd_ssthresh\030\320\t \001(\rR\022tcpInfoSndSsthresh\022" - "*\n\021tcp_info_snd_cwnd\030\321\t \001(\rR\016tcpInfoSndC" - "wnd\022(\n\020tcp_info_adv_mss\030\322\t \001(\rR\rtcpInfoA" - "dvMss\022/\n\023tcp_info_reordering\030\323\t \001(\rR\021tcp" - "InfoReordering\022(\n\020tcp_info_rcv_rtt\030\324\t \001(" - "\rR\rtcpInfoRcvRtt\022,\n\022tcp_info_rcv_space\030\325" - "\t \001(\rR\017tcpInfoRcvSpace\0224\n\026tcp_info_total" - "_retrans\030\326\t \001(\rR\023tcpInfoTotalRetrans\0220\n\024" - "tcp_info_pacing_rate\030\327\t \001(\004R\021tcpInfoPaci" - "ngRate\0227\n\030tcp_info_max_pacing_rate\030\330\t \001(" - "\004R\024tcpInfoMaxPacingRate\0220\n\024tcp_info_byte" - "s_acked\030\331\t \001(\004R\021tcpInfoBytesAcked\0226\n\027tcp" - "_info_bytes_received\030\332\t \001(\004R\024tcpInfoByte" - "sReceived\022*\n\021tcp_info_segs_out\030\333\t \001(\rR\016t" - "cpInfoSegsOut\022(\n\020tcp_info_segs_in\030\334\t \001(\r" - "R\rtcpInfoSegsIn\0225\n\027tcp_info_not_sent_byt" - "es\030\335\t \001(\rR\023tcpInfoNotSentBytes\022(\n\020tcp_in" - "fo_min_rtt\030\336\t \001(\rR\rtcpInfoMinRtt\0221\n\025tcp_" - "info_data_segs_in\030\337\t \001(\rR\021tcpInfoDataSeg" - "sIn\0223\n\026tcp_info_data_segs_out\030\340\t \001(\rR\022tc" - "pInfoDataSegsOut\0224\n\026tcp_info_delivery_ra" - "te\030\341\t \001(\004R\023tcpInfoDeliveryRate\022,\n\022tcp_in" - "fo_busy_time\030\342\t \001(\004R\017tcpInfoBusyTime\0222\n\025" - "tcp_info_rwnd_limited\030\343\t \001(\004R\022tcpInfoRwn" - "dLimited\0226\n\027tcp_info_sndbuf_limited\030\344\t \001" - "(\004R\024tcpInfoSndbufLimited\022-\n\022tcp_info_del" - "ivered\030\345\t \001(\rR\020tcpInfoDelivered\0222\n\025tcp_i" - "nfo_delivered_ce\030\346\t \001(\rR\022tcpInfoDelivere" - "dCe\022.\n\023tcp_info_bytes_sent\030\347\t \001(\004R\020tcpIn" - "foBytesSent\0224\n\026tcp_info_bytes_retrans\030\350\t" - " \001(\004R\023tcpInfoBytesRetrans\022.\n\023tcp_info_ds" - "ack_dups\030\351\t \001(\rR\020tcpInfoDsackDups\022.\n\023tcp" - "_info_reord_seen\030\352\t \001(\rR\020tcpInfoReordSee" - "n\0220\n\024tcp_info_rcv_ooopack\030\353\t \001(\rR\021tcpInf" - "oRcvOoopack\022(\n\020tcp_info_snd_wnd\030\354\t \001(\rR\r" - "tcpInfoSndWnd\022(\n\020tcp_info_rcv_wnd\030\355\t \001(\r" - "R\rtcpInfoRcvWnd\022\'\n\017tcp_info_rehash\030\356\t \001(" - "\rR\rtcpInfoRehash\022,\n\022tcp_info_total_rto\030\357" - "\t \001(\rR\017tcpInfoTotalRto\022A\n\035tcp_info_total" - "_rto_recoveries\030\360\t \001(\rR\031tcpInfoTotalRtoR" - "ecoveries\0225\n\027tcp_info_total_rto_time\030\361\t " - "\001(\rR\023tcpInfoTotalRtoTime\022\?\n\033congestion_a" - "lgorithm_string\030\224\n \001(\tR\031congestionAlgori" - "thmString\022t\n\031congestion_algorithm_enum\030\225" - "\n \001(\01627.xtcp_flat_record.v1.XtcpFlatReco" - "rd.CongestionAlgorithmR\027congestionAlgori" - "thmEnum\022\'\n\017type_of_service\030\371\n \001(\rR\rtypeO" - "fService\022$\n\rtraffic_class\030\372\n \001(\rR\014traffi" - "cClass\0223\n\026sk_mem_info_rmem_alloc\030\335\013 \001(\rR" - "\022skMemInfoRmemAlloc\022-\n\023sk_mem_info_rcv_b" - "uf\030\336\013 \001(\rR\017skMemInfoRcvBuf\0223\n\026sk_mem_inf" - "o_wmem_alloc\030\337\013 \001(\rR\022skMemInfoWmemAlloc\022" - "-\n\023sk_mem_info_snd_buf\030\340\013 \001(\rR\017skMemInfo" - "SndBuf\0221\n\025sk_mem_info_fwd_alloc\030\341\013 \001(\rR\021" - "skMemInfoFwdAlloc\0225\n\027sk_mem_info_wmem_qu" - "eued\030\342\013 \001(\rR\023skMemInfoWmemQueued\022,\n\022sk_m" - "em_info_optmem\030\343\013 \001(\rR\017skMemInfoOptmem\022." - "\n\023sk_mem_info_backlog\030\344\013 \001(\rR\020skMemInfoB" - "acklog\022*\n\021sk_mem_info_drops\030\345\013 \001(\rR\016skMe" - "mInfoDrops\022&\n\016shutdown_state\030\300\014 \001(\rR\rshu" - "tdownState\022-\n\022vegas_info_enabled\030\245\r \001(\rR" - "\020vegasInfoEnabled\022,\n\022vegas_info_rtt_cnt\030" - "\246\r \001(\rR\017vegasInfoRttCnt\022%\n\016vegas_info_rt" - "t\030\247\r \001(\rR\014vegasInfoRtt\022,\n\022vegas_info_min" - "_rtt\030\250\r \001(\rR\017vegasInfoMinRtt\022-\n\022dctcp_in" - "fo_enabled\030\211\016 \001(\rR\020dctcpInfoEnabled\022.\n\023d" - "ctcp_info_ce_state\030\212\016 \001(\rR\020dctcpInfoCeSt" - "ate\022)\n\020dctcp_info_alpha\030\213\016 \001(\rR\016dctcpInf" - "oAlpha\022*\n\021dctcp_info_ab_ecn\030\214\016 \001(\rR\016dctc" - "pInfoAbEcn\022*\n\021dctcp_info_ab_tot\030\215\016 \001(\rR\016" - "dctcpInfoAbTot\022$\n\016bbr_info_bw_lo\030\355\016 \001(\rR" - "\013bbrInfoBwLo\022$\n\016bbr_info_bw_hi\030\356\016 \001(\rR\013b" - "brInfoBwHi\022(\n\020bbr_info_min_rtt\030\357\016 \001(\rR\rb" - "brInfoMinRtt\0220\n\024bbr_info_pacing_gain\030\360\016 " - "\001(\rR\021bbrInfoPacingGain\022,\n\022bbr_info_cwnd_" - "gain\030\361\016 \001(\rR\017bbrInfoCwndGain\022\032\n\010class_id" - "\030\321\017 \001(\rR\007classId\022\032\n\010sock_opt\030\322\017 \001(\rR\007soc" - "kOpt\022\030\n\007c_group\030\267\020 \001(\004R\006cGroup\"\231\002\n\023Conge" - "stionAlgorithm\022$\n CONGESTION_ALGORITHM_U" - "NSPECIFIED\020\000\022\036\n\032CONGESTION_ALGORITHM_CUB" - "IC\020\001\022\036\n\032CONGESTION_ALGORITHM_DCTCP\020\002\022\036\n\032" - "CONGESTION_ALGORITHM_VEGAS\020\003\022\037\n\033CONGESTI" - "ON_ALGORITHM_PRAGUE\020\004\022\035\n\031CONGESTION_ALGO" - "RITHM_BBR1\020\005\022\035\n\031CONGESTION_ALGORITHM_BBR" - "2\020\006\022\035\n\031CONGESTION_ALGORITHM_BBR3\020\007\"\024\n\022Fl" - "atRecordsRequest\"d\n\023FlatRecordsResponse\022" - "M\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp_flat_re" - "cord.v1.XtcpFlatRecordR\016xtcpFlatRecord\"\030" - "\n\026PollFlatRecordsRequest\"h\n\027PollFlatReco" - "rdsResponse\022M\n\020xtcp_flat_record\030\001 \001(\0132#." - "xtcp_flat_record.v1.XtcpFlatRecordR\016xtcp" - "FlatRecord2\355\001\n\025XTCPFlatRecordService\022b\n\013" - "FlatRecords\022\'.xtcp_flat_record.v1.FlatRe" - "cordsRequest\032(.xtcp_flat_record.v1.FlatR" - "ecordsResponse0\001\022p\n\017PollFlatRecords\022+.xt" - "cp_flat_record.v1.PollFlatRecordsRequest" - "\032,.xtcp_flat_record.v1.PollFlatRecordsRe" - "sponse(\0010\001B\256\001\n\027com.xtcp_flat_record.v1B\023" - "XtcpFlatRecordProtoP\001Z\031./gen/go/xtcp_fla" - "t_record\242\002\003XXX\252\002\021XtcpFlatRecord.V1\312\002\021Xtc" - "pFlatRecord\\V1\342\002\035XtcpFlatRecord\\V1\\GPBMe" - "tadata\352\002\022XtcpFlatRecord::V1b\006proto3" + "inetDiagMsgSocketDestNetworkOwner\022x\n\"ine" + "t_diag_msg_socket_dest_locality\030\373\007 \001(\0162," + ".xtcp_flat_record.v1.XtcpFlatRecord.Loca" + "lityR\035inetDiagMsgSocketDestLocality\022#\n\rm" + "em_info_rmem\030\315\010 \001(\rR\013memInfoRmem\022#\n\rmem_" + "info_wmem\030\316\010 \001(\rR\013memInfoWmem\022#\n\rmem_inf" + "o_fmem\030\317\010 \001(\rR\013memInfoFmem\022#\n\rmem_info_t" + "mem\030\320\010 \001(\rR\013memInfoTmem\022%\n\016tcp_info_stat" + "e\030\261\t \001(\rR\014tcpInfoState\022*\n\021tcp_info_ca_st" + "ate\030\262\t \001(\rR\016tcpInfoCaState\0221\n\024tcp_info_r" + "etransmits\030\263\t \001(\rR\022tcpInfoRetransmits\022\'\n" + "\017tcp_info_probes\030\264\t \001(\rR\rtcpInfoProbes\022)" + "\n\020tcp_info_backoff\030\265\t \001(\rR\016tcpInfoBackof" + "f\022)\n\020tcp_info_options\030\266\t \001(\rR\016tcpInfoOpt" + "ions\022.\n\023tcp_info_send_scale\030\267\t \001(\rR\020tcpI" + "nfoSendScale\022,\n\022tcp_info_rcv_scale\030\270\t \001(" + "\rR\017tcpInfoRcvScale\022J\n\"tcp_info_delivery_" + "rate_app_limited\030\271\t \001(\rR\035tcpInfoDelivery" + "RateAppLimited\022F\n tcp_info_fast_open_cli" + "ent_failed\030\272\t \001(\rR\033tcpInfoFastOpenClient" + "Failed\022!\n\014tcp_info_rto\030\277\t \001(\rR\ntcpInfoRt" + "o\022!\n\014tcp_info_ato\030\300\t \001(\rR\ntcpInfoAto\022(\n\020" + "tcp_info_snd_mss\030\301\t \001(\rR\rtcpInfoSndMss\022(" + "\n\020tcp_info_rcv_mss\030\302\t \001(\rR\rtcpInfoRcvMss" + "\022)\n\020tcp_info_unacked\030\303\t \001(\rR\016tcpInfoUnac" + "ked\022\'\n\017tcp_info_sacked\030\304\t \001(\rR\rtcpInfoSa" + "cked\022#\n\rtcp_info_lost\030\305\t \001(\rR\013tcpInfoLos" + "t\022)\n\020tcp_info_retrans\030\306\t \001(\rR\016tcpInfoRet" + "rans\022)\n\020tcp_info_fackets\030\307\t \001(\rR\016tcpInfo" + "Fackets\0225\n\027tcp_info_last_data_sent\030\310\t \001(" + "\rR\023tcpInfoLastDataSent\0223\n\026tcp_info_last_" + "ack_sent\030\311\t \001(\rR\022tcpInfoLastAckSent\0225\n\027t" + "cp_info_last_data_recv\030\312\t \001(\rR\023tcpInfoLa" + "stDataRecv\0223\n\026tcp_info_last_ack_recv\030\313\t " + "\001(\rR\022tcpInfoLastAckRecv\022#\n\rtcp_info_pmtu" + "\030\314\t \001(\rR\013tcpInfoPmtu\0222\n\025tcp_info_rcv_sst" + "hresh\030\315\t \001(\rR\022tcpInfoRcvSsthresh\022!\n\014tcp_" + "info_rtt\030\316\t \001(\rR\ntcpInfoRtt\022(\n\020tcp_info_" + "rtt_var\030\317\t \001(\rR\rtcpInfoRttVar\0222\n\025tcp_inf" + "o_snd_ssthresh\030\320\t \001(\rR\022tcpInfoSndSsthres" + "h\022*\n\021tcp_info_snd_cwnd\030\321\t \001(\rR\016tcpInfoSn" + "dCwnd\022(\n\020tcp_info_adv_mss\030\322\t \001(\rR\rtcpInf" + "oAdvMss\022/\n\023tcp_info_reordering\030\323\t \001(\rR\021t" + "cpInfoReordering\022(\n\020tcp_info_rcv_rtt\030\324\t " + "\001(\rR\rtcpInfoRcvRtt\022,\n\022tcp_info_rcv_space" + "\030\325\t \001(\rR\017tcpInfoRcvSpace\0224\n\026tcp_info_tot" + "al_retrans\030\326\t \001(\rR\023tcpInfoTotalRetrans\0220" + "\n\024tcp_info_pacing_rate\030\327\t \001(\004R\021tcpInfoPa" + "cingRate\0227\n\030tcp_info_max_pacing_rate\030\330\t " + "\001(\004R\024tcpInfoMaxPacingRate\0220\n\024tcp_info_by" + "tes_acked\030\331\t \001(\004R\021tcpInfoBytesAcked\0226\n\027t" + "cp_info_bytes_received\030\332\t \001(\004R\024tcpInfoBy" + "tesReceived\022*\n\021tcp_info_segs_out\030\333\t \001(\rR" + "\016tcpInfoSegsOut\022(\n\020tcp_info_segs_in\030\334\t \001" + "(\rR\rtcpInfoSegsIn\0225\n\027tcp_info_not_sent_b" + "ytes\030\335\t \001(\rR\023tcpInfoNotSentBytes\022(\n\020tcp_" + "info_min_rtt\030\336\t \001(\rR\rtcpInfoMinRtt\0221\n\025tc" + "p_info_data_segs_in\030\337\t \001(\rR\021tcpInfoDataS" + "egsIn\0223\n\026tcp_info_data_segs_out\030\340\t \001(\rR\022" + "tcpInfoDataSegsOut\0224\n\026tcp_info_delivery_" + "rate\030\341\t \001(\004R\023tcpInfoDeliveryRate\022,\n\022tcp_" + "info_busy_time\030\342\t \001(\004R\017tcpInfoBusyTime\0222" + "\n\025tcp_info_rwnd_limited\030\343\t \001(\004R\022tcpInfoR" + "wndLimited\0226\n\027tcp_info_sndbuf_limited\030\344\t" + " \001(\004R\024tcpInfoSndbufLimited\022-\n\022tcp_info_d" + "elivered\030\345\t \001(\rR\020tcpInfoDelivered\0222\n\025tcp" + "_info_delivered_ce\030\346\t \001(\rR\022tcpInfoDelive" + "redCe\022.\n\023tcp_info_bytes_sent\030\347\t \001(\004R\020tcp" + "InfoBytesSent\0224\n\026tcp_info_bytes_retrans\030" + "\350\t \001(\004R\023tcpInfoBytesRetrans\022.\n\023tcp_info_" + "dsack_dups\030\351\t \001(\rR\020tcpInfoDsackDups\022.\n\023t" + "cp_info_reord_seen\030\352\t \001(\rR\020tcpInfoReordS" + "een\0220\n\024tcp_info_rcv_ooopack\030\353\t \001(\rR\021tcpI" + "nfoRcvOoopack\022(\n\020tcp_info_snd_wnd\030\354\t \001(\r" + "R\rtcpInfoSndWnd\022(\n\020tcp_info_rcv_wnd\030\355\t \001" + "(\rR\rtcpInfoRcvWnd\022\'\n\017tcp_info_rehash\030\356\t " + "\001(\rR\rtcpInfoRehash\022,\n\022tcp_info_total_rto" + "\030\357\t \001(\rR\017tcpInfoTotalRto\022A\n\035tcp_info_tot" + "al_rto_recoveries\030\360\t \001(\rR\031tcpInfoTotalRt" + "oRecoveries\0225\n\027tcp_info_total_rto_time\030\361" + "\t \001(\rR\023tcpInfoTotalRtoTime\022\?\n\033congestion" + "_algorithm_string\030\224\n \001(\tR\031congestionAlgo" + "rithmString\022t\n\031congestion_algorithm_enum" + "\030\225\n \001(\01627.xtcp_flat_record.v1.XtcpFlatRe" + "cord.CongestionAlgorithmR\027congestionAlgo" + "rithmEnum\022\'\n\017type_of_service\030\371\n \001(\rR\rtyp" + "eOfService\022$\n\rtraffic_class\030\372\n \001(\rR\014traf" + "ficClass\0223\n\026sk_mem_info_rmem_alloc\030\335\013 \001(" + "\rR\022skMemInfoRmemAlloc\022-\n\023sk_mem_info_rcv" + "_buf\030\336\013 \001(\rR\017skMemInfoRcvBuf\0223\n\026sk_mem_i" + "nfo_wmem_alloc\030\337\013 \001(\rR\022skMemInfoWmemAllo" + "c\022-\n\023sk_mem_info_snd_buf\030\340\013 \001(\rR\017skMemIn" + "foSndBuf\0221\n\025sk_mem_info_fwd_alloc\030\341\013 \001(\r" + "R\021skMemInfoFwdAlloc\0225\n\027sk_mem_info_wmem_" + "queued\030\342\013 \001(\rR\023skMemInfoWmemQueued\022,\n\022sk" + "_mem_info_optmem\030\343\013 \001(\rR\017skMemInfoOptmem" + "\022.\n\023sk_mem_info_backlog\030\344\013 \001(\rR\020skMemInf" + "oBacklog\022*\n\021sk_mem_info_drops\030\345\013 \001(\rR\016sk" + "MemInfoDrops\022&\n\016shutdown_state\030\300\014 \001(\rR\rs" + "hutdownState\022-\n\022vegas_info_enabled\030\245\r \001(" + "\rR\020vegasInfoEnabled\022,\n\022vegas_info_rtt_cn" + "t\030\246\r \001(\rR\017vegasInfoRttCnt\022%\n\016vegas_info_" + "rtt\030\247\r \001(\rR\014vegasInfoRtt\022,\n\022vegas_info_m" + "in_rtt\030\250\r \001(\rR\017vegasInfoMinRtt\022-\n\022dctcp_" + "info_enabled\030\211\016 \001(\rR\020dctcpInfoEnabled\022.\n" + "\023dctcp_info_ce_state\030\212\016 \001(\rR\020dctcpInfoCe" + "State\022)\n\020dctcp_info_alpha\030\213\016 \001(\rR\016dctcpI" + "nfoAlpha\022*\n\021dctcp_info_ab_ecn\030\214\016 \001(\rR\016dc" + "tcpInfoAbEcn\022*\n\021dctcp_info_ab_tot\030\215\016 \001(\r" + "R\016dctcpInfoAbTot\022$\n\016bbr_info_bw_lo\030\355\016 \001(" + "\rR\013bbrInfoBwLo\022$\n\016bbr_info_bw_hi\030\356\016 \001(\rR" + "\013bbrInfoBwHi\022(\n\020bbr_info_min_rtt\030\357\016 \001(\rR" + "\rbbrInfoMinRtt\0220\n\024bbr_info_pacing_gain\030\360" + "\016 \001(\rR\021bbrInfoPacingGain\022,\n\022bbr_info_cwn" + "d_gain\030\361\016 \001(\rR\017bbrInfoCwndGain\022\032\n\010class_" + "id\030\321\017 \001(\rR\007classId\022\032\n\010sock_opt\030\322\017 \001(\rR\007s" + "ockOpt\022\030\n\007c_group\030\267\020 \001(\004R\006cGroup\"g\n\010Loca" + "lity\022\030\n\024LOCALITY_UNSPECIFIED\020\000\022\021\n\rLOCALI" + "TY_SELF\020\001\022\031\n\025LOCALITY_LOCAL_SUBNET\020\002\022\023\n\017" + "LOCALITY_REMOTE\020\003\"\231\002\n\023CongestionAlgorith" + "m\022$\n CONGESTION_ALGORITHM_UNSPECIFIED\020\000\022" + "\036\n\032CONGESTION_ALGORITHM_CUBIC\020\001\022\036\n\032CONGE" + "STION_ALGORITHM_DCTCP\020\002\022\036\n\032CONGESTION_AL" + "GORITHM_VEGAS\020\003\022\037\n\033CONGESTION_ALGORITHM_" + "PRAGUE\020\004\022\035\n\031CONGESTION_ALGORITHM_BBR1\020\005\022" + "\035\n\031CONGESTION_ALGORITHM_BBR2\020\006\022\035\n\031CONGES" + "TION_ALGORITHM_BBR3\020\007\"\024\n\022FlatRecordsRequ" + "est\"d\n\023FlatRecordsResponse\022M\n\020xtcp_flat_" + "record\030\001 \001(\0132#.xtcp_flat_record.v1.XtcpF" + "latRecordR\016xtcpFlatRecord\"\030\n\026PollFlatRec" + "ordsRequest\"h\n\027PollFlatRecordsResponse\022M" + "\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp_flat_rec" + "ord.v1.XtcpFlatRecordR\016xtcpFlatRecord2\355\001" + "\n\025XTCPFlatRecordService\022b\n\013FlatRecords\022\'" + ".xtcp_flat_record.v1.FlatRecordsRequest\032" + "(.xtcp_flat_record.v1.FlatRecordsRespons" + "e0\001\022p\n\017PollFlatRecords\022+.xtcp_flat_recor" + "d.v1.PollFlatRecordsRequest\032,.xtcp_flat_" + "record.v1.PollFlatRecordsResponse(\0010\001B\256\001" + "\n\027com.xtcp_flat_record.v1B\023XtcpFlatRecor" + "dProtoP\001Z\031./gen/go/xtcp_flat_record\242\002\003XX" + "X\252\002\021XtcpFlatRecord.V1\312\002\021XtcpFlatRecord\\V" + "1\342\002\035XtcpFlatRecord\\V1\\GPBMetadata\352\002\022Xtcp" + "FlatRecord::V1b\006proto3" }; static ::absl::once_flag descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto = { false, false, - 8595, + 8822, descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto, "xtcp_flat_record/v1/xtcp_flat_record.proto", &descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once, @@ -2181,10 +2192,17 @@ PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fflat_5f namespace xtcp_flat_record { namespace v1 { [[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL -XtcpFlatRecord_CongestionAlgorithm_descriptor() { +XtcpFlatRecord_Locality_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto); return file_level_enum_descriptors_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto[0]; } +PROTOBUF_CONSTINIT const uint32_t XtcpFlatRecord_Locality_internal_data_[] = { + 262144u, 0u, }; +[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL +XtcpFlatRecord_CongestionAlgorithm_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto); + return file_level_enum_descriptors_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto[1]; +} PROTOBUF_CONSTINIT const uint32_t XtcpFlatRecord_CongestionAlgorithm_internal_data_[] = { 524288u, 0u, }; // =================================================================== @@ -2486,9 +2504,9 @@ XtcpFlatRecord::XtcpFlatRecord( offsetof(Impl_, netlinker_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, netlinker_id_), - offsetof(Impl_, c_group_) - + offsetof(Impl_, sock_opt_) - offsetof(Impl_, netlinker_id_) + - sizeof(Impl_::c_group_)); + sizeof(Impl_::sock_opt_)); // @@protoc_insertion_point(copy_constructor:xtcp_flat_record.v1.XtcpFlatRecord) } @@ -2542,9 +2560,9 @@ inline void XtcpFlatRecord::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, netlinker_id_), 0, - offsetof(Impl_, c_group_) - + offsetof(Impl_, sock_opt_) - offsetof(Impl_, netlinker_id_) + - sizeof(Impl_::c_group_)); + sizeof(Impl_::sock_opt_)); } XtcpFlatRecord::~XtcpFlatRecord() { // @@protoc_insertion_point(destructor:xtcp_flat_record.v1.XtcpFlatRecord) @@ -2763,71 +2781,71 @@ PROTOBUF_NOINLINE void XtcpFlatRecord::Clear() { } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { ::memset(&_impl_.inet_diag_msg_socket_dest_asn_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.mem_info_wmem_) - - reinterpret_cast(&_impl_.inet_diag_msg_socket_dest_asn_)) + sizeof(_impl_.mem_info_wmem_)); + reinterpret_cast(&_impl_.mem_info_rmem_) - + reinterpret_cast(&_impl_.inet_diag_msg_socket_dest_asn_)) + sizeof(_impl_.mem_info_rmem_)); } cached_has_bits = _impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.mem_info_fmem_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_options_) - - reinterpret_cast(&_impl_.mem_info_fmem_)) + sizeof(_impl_.tcp_info_options_)); + ::memset(&_impl_.mem_info_wmem_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_backoff_) - + reinterpret_cast(&_impl_.mem_info_wmem_)) + sizeof(_impl_.tcp_info_backoff_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_send_scale_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_rcv_mss_) - - reinterpret_cast(&_impl_.tcp_info_send_scale_)) + sizeof(_impl_.tcp_info_rcv_mss_)); + ::memset(&_impl_.tcp_info_options_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_snd_mss_) - + reinterpret_cast(&_impl_.tcp_info_options_)) + sizeof(_impl_.tcp_info_snd_mss_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_unacked_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_last_data_recv_) - - reinterpret_cast(&_impl_.tcp_info_unacked_)) + sizeof(_impl_.tcp_info_last_data_recv_)); + ::memset(&_impl_.tcp_info_rcv_mss_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_last_ack_sent_) - + reinterpret_cast(&_impl_.tcp_info_rcv_mss_)) + sizeof(_impl_.tcp_info_last_ack_sent_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_last_ack_recv_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_adv_mss_) - - reinterpret_cast(&_impl_.tcp_info_last_ack_recv_)) + sizeof(_impl_.tcp_info_adv_mss_)); + ::memset(&_impl_.tcp_info_last_data_recv_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_snd_cwnd_) - + reinterpret_cast(&_impl_.tcp_info_last_data_recv_)) + sizeof(_impl_.tcp_info_snd_cwnd_)); } cached_has_bits = _impl_._has_bits_[3]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.tcp_info_reordering_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_bytes_received_) - - reinterpret_cast(&_impl_.tcp_info_reordering_)) + sizeof(_impl_.tcp_info_bytes_received_)); + ::memset(&_impl_.tcp_info_adv_mss_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_segs_out_) - + reinterpret_cast(&_impl_.tcp_info_adv_mss_)) + sizeof(_impl_.tcp_info_segs_out_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_segs_out_, 0, static_cast<::size_t>( + ::memset(&_impl_.tcp_info_bytes_acked_, 0, static_cast<::size_t>( reinterpret_cast(&_impl_.tcp_info_busy_time_) - - reinterpret_cast(&_impl_.tcp_info_segs_out_)) + sizeof(_impl_.tcp_info_busy_time_)); + reinterpret_cast(&_impl_.tcp_info_bytes_acked_)) + sizeof(_impl_.tcp_info_busy_time_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_rwnd_limited_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_reord_seen_) - - reinterpret_cast(&_impl_.tcp_info_rwnd_limited_)) + sizeof(_impl_.tcp_info_reord_seen_)); + ::memset(&_impl_.tcp_info_data_segs_out_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_bytes_retrans_) - + reinterpret_cast(&_impl_.tcp_info_data_segs_out_)) + sizeof(_impl_.tcp_info_bytes_retrans_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_rcv_ooopack_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.congestion_algorithm_enum_) - - reinterpret_cast(&_impl_.tcp_info_rcv_ooopack_)) + sizeof(_impl_.congestion_algorithm_enum_)); + ::memset(&_impl_.tcp_info_reord_seen_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_total_rto_time_) - + reinterpret_cast(&_impl_.tcp_info_reord_seen_)) + sizeof(_impl_.tcp_info_total_rto_time_)); } cached_has_bits = _impl_._has_bits_[4]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.type_of_service_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.sk_mem_info_wmem_queued_) - - reinterpret_cast(&_impl_.type_of_service_)) + sizeof(_impl_.sk_mem_info_wmem_queued_)); + ::memset(&_impl_.congestion_algorithm_enum_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.sk_mem_info_fwd_alloc_) - + reinterpret_cast(&_impl_.congestion_algorithm_enum_)) + sizeof(_impl_.sk_mem_info_fwd_alloc_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.sk_mem_info_optmem_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.vegas_info_min_rtt_) - - reinterpret_cast(&_impl_.sk_mem_info_optmem_)) + sizeof(_impl_.vegas_info_min_rtt_)); + ::memset(&_impl_.sk_mem_info_wmem_queued_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.vegas_info_rtt_) - + reinterpret_cast(&_impl_.sk_mem_info_wmem_queued_)) + sizeof(_impl_.vegas_info_rtt_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.dctcp_info_enabled_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.bbr_info_min_rtt_) - - reinterpret_cast(&_impl_.dctcp_info_enabled_)) + sizeof(_impl_.bbr_info_min_rtt_)); + ::memset(&_impl_.vegas_info_min_rtt_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.bbr_info_bw_hi_) - + reinterpret_cast(&_impl_.vegas_info_min_rtt_)) + sizeof(_impl_.bbr_info_bw_hi_)); } - if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { - ::memset(&_impl_.bbr_info_pacing_gain_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.c_group_) - - reinterpret_cast(&_impl_.bbr_info_pacing_gain_)) + sizeof(_impl_.c_group_)); + if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { + ::memset(&_impl_.bbr_info_min_rtt_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.sock_opt_) - + reinterpret_cast(&_impl_.bbr_info_min_rtt_)) + sizeof(_impl_.sock_opt_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); @@ -3441,8 +3459,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (this_._internal_inet_diag_msg_socket_dest_locality() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1019, this_._internal_inet_diag_msg_socket_dest_locality(), target); + } + } + + // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_mem_info_rmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3450,8 +3477,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_mem_info_wmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3459,9 +3487,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[2]; // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_mem_info_fmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3470,7 +3497,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_mem_info_tmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3479,7 +3506,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3488,7 +3515,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_ca_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3497,7 +3524,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_retransmits() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3506,7 +3533,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_probes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3515,7 +3542,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_backoff() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3524,7 +3551,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_options() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3533,7 +3560,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_send_scale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3542,7 +3569,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_rcv_scale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3551,7 +3578,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3560,7 +3587,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_fast_open_client_failed() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3569,7 +3596,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3578,7 +3605,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_ato() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3587,7 +3614,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3596,7 +3623,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3605,7 +3632,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_unacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3614,7 +3641,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_sacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3623,7 +3650,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_lost() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3632,7 +3659,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3641,7 +3668,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_fackets() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3650,7 +3677,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3659,7 +3686,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3668,7 +3695,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3677,7 +3704,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3686,7 +3713,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3695,7 +3722,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3704,7 +3731,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3713,7 +3740,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_rtt_var() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3722,7 +3749,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3731,7 +3758,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3739,8 +3766,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[3]; // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_adv_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3748,9 +3776,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[3]; // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_reordering() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3759,7 +3786,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3768,7 +3795,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_rcv_space() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3777,7 +3804,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_total_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3804,7 +3831,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3813,7 +3840,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_bytes_received() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3822,7 +3849,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3831,7 +3858,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3840,7 +3867,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_not_sent_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3849,7 +3876,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3858,7 +3885,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3867,7 +3894,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_data_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3894,7 +3921,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_rwnd_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3903,7 +3930,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_sndbuf_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3912,7 +3939,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_delivered() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3921,7 +3948,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_delivered_ce() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3939,7 +3966,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_bytes_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3957,7 +3984,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3966,7 +3993,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3975,7 +4002,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3984,7 +4011,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3993,7 +4020,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rehash() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4002,7 +4029,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_total_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4011,7 +4038,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4020,7 +4047,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4039,9 +4066,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[3]; + cached_has_bits = this_._impl_._has_bits_[4]; // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_congestion_algorithm_enum() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( @@ -4049,9 +4076,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[4]; // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_type_of_service() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4060,7 +4086,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_traffic_class() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4069,7 +4095,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4078,7 +4104,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_sk_mem_info_rcv_buf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4087,7 +4113,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4096,7 +4122,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_snd_buf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4105,7 +4131,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4114,7 +4140,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4123,7 +4149,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_sk_mem_info_optmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4132,7 +4158,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_backlog() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4141,7 +4167,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_sk_mem_info_drops() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4150,7 +4176,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_shutdown_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4159,7 +4185,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_vegas_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4168,7 +4194,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_vegas_info_rtt_cnt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4177,7 +4203,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_vegas_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4186,7 +4212,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_vegas_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4195,7 +4221,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_dctcp_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4204,7 +4230,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4213,7 +4239,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_dctcp_info_alpha() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4222,7 +4248,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4231,7 +4257,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4240,7 +4266,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4249,7 +4275,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4258,7 +4284,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4267,7 +4293,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4276,7 +4302,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4285,7 +4311,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_class_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4294,7 +4320,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_sock_opt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4786,284 +4812,284 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_inet_diag_msg_inode()); } } - // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (this_._internal_inet_diag_msg_socket_dest_locality() != 0) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_inet_diag_msg_socket_dest_locality()); + } + } + // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_mem_info_rmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_rmem()); } } + } + cached_has_bits = this_._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_mem_info_wmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_wmem()); } } - } - cached_has_bits = this_._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_mem_info_fmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_fmem()); } } // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_mem_info_tmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_tmem()); } } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_state()); } } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_ca_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ca_state()); } } // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_retransmits() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retransmits()); } } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_probes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_probes()); } } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_backoff() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_backoff()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_options() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_options()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_send_scale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_send_scale()); } } // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_rcv_scale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_scale()); } } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivery_rate_app_limited()); } } // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_fast_open_client_failed() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_fast_open_client_failed()); } } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rto()); } } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_ato() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ato()); } } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_mss()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_mss()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_unacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_unacked()); } } // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_sacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_sacked()); } } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_lost() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_lost()); } } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retrans()); } } // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_fackets() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_fackets()); } } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_sent()); } } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_sent()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_recv()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_recv()); } } // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_pmtu()); } } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ssthresh()); } } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rtt()); } } // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_rtt_var() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rtt_var()); } } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_ssthresh()); } } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_cwnd()); } } + } + cached_has_bits = this_._impl_._has_bits_[3]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_adv_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_adv_mss()); } } - } - cached_has_bits = this_._impl_._has_bits_[3]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_reordering() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reordering()); } } // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_rtt()); } } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_tcp_info_rcv_space() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_space()); } } - // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (this_._internal_tcp_info_total_retrans() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_total_retrans()); - } - } // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_pacing_rate() != 0) { @@ -5078,64 +5104,64 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_tcp_info_max_pacing_rate()); } } - // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; + // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (this_._internal_tcp_info_total_retrans() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_tcp_info_total_retrans()); + } + } + // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (this_._internal_tcp_info_segs_out() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_tcp_info_segs_out()); + } + } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_acked()); } } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_bytes_received() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_received()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (this_._internal_tcp_info_segs_out() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_segs_out()); - } - } // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_segs_in()); } } // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_not_sent_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_not_sent_bytes()); } } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_min_rtt()); } } // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_data_segs_in()); } } - // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (this_._internal_tcp_info_data_segs_out() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_data_segs_out()); - } - } // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_delivery_rate() != 0) { @@ -5152,32 +5178,32 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { } } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; + // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_tcp_info_rwnd_limited() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_tcp_info_rwnd_limited()); - } - } - // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (this_._internal_tcp_info_sndbuf_limited() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_tcp_info_sndbuf_limited()); + if (this_._internal_tcp_info_data_segs_out() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_tcp_info_data_segs_out()); } } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_delivered() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivered()); } } - // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; + // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (this_._internal_tcp_info_rwnd_limited() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_tcp_info_rwnd_limited()); + } + } + // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (this_._internal_tcp_info_delivered_ce() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_delivered_ce()); + if (this_._internal_tcp_info_sndbuf_limited() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_tcp_info_sndbuf_limited()); } } // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; @@ -5187,11 +5213,11 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_tcp_info_bytes_sent()); } } - // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; + // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (this_._internal_tcp_info_bytes_retrans() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_tcp_info_bytes_retrans()); + if (this_._internal_tcp_info_delivered_ce() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_tcp_info_delivered_ce()); } } // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; @@ -5201,276 +5227,276 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_tcp_info_dsack_dups()); } } - // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; + // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (this_._internal_tcp_info_bytes_retrans() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_tcp_info_bytes_retrans()); + } + } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reord_seen()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ooopack()); } } // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_wnd()); } } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_wnd()); } } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rehash() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rehash()); } } // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_total_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto()); } } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_recoveries()); } } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_time()); } } + } + cached_has_bits = this_._impl_._has_bits_[4]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_congestion_algorithm_enum() != 0) { total_size += 2 + ::_pbi::WireFormatLite::EnumSize(this_._internal_congestion_algorithm_enum()); } } - } - cached_has_bits = this_._impl_._has_bits_[4]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_type_of_service() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_type_of_service()); } } // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_traffic_class() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_traffic_class()); } } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_rmem_alloc()); } } // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_sk_mem_info_rcv_buf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_rcv_buf()); } } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_alloc()); } } // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_snd_buf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_snd_buf()); } } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_fwd_alloc()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_queued()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_sk_mem_info_optmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_optmem()); } } // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_backlog() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_backlog()); } } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_sk_mem_info_drops() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_drops()); } } // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_shutdown_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_shutdown_state()); } } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_vegas_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_enabled()); } } // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_vegas_info_rtt_cnt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_rtt_cnt()); } } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_vegas_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_rtt()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_vegas_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_min_rtt()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_dctcp_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_enabled()); } } // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ce_state()); } } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_dctcp_info_alpha() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_alpha()); } } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_ecn()); } } // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_tot()); } } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_lo()); } } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_hi()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_min_rtt()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_pacing_gain()); } } // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_cwnd_gain()); } } // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_class_id() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_class_id()); } } - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (this_._internal_sock_opt() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_sock_opt()); - } - } // uint64 c_group = 2103 [json_name = "cGroup"]; if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_c_group() != 0) { @@ -5478,6 +5504,13 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_c_group()); } } + // uint32 sock_opt = 2002 [json_name = "sockOpt"]; + if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (this_._internal_sock_opt() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_sock_opt()); + } + } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); @@ -5959,207 +5992,207 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (from._internal_mem_info_rmem() != 0) { - _this->_impl_.mem_info_rmem_ = from._impl_.mem_info_rmem_; + if (from._internal_inet_diag_msg_socket_dest_locality() != 0) { + _this->_impl_.inet_diag_msg_socket_dest_locality_ = from._impl_.inet_diag_msg_socket_dest_locality_; } } if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_mem_info_wmem() != 0) { - _this->_impl_.mem_info_wmem_ = from._impl_.mem_info_wmem_; + if (from._internal_mem_info_rmem() != 0) { + _this->_impl_.mem_info_rmem_ = from._impl_.mem_info_rmem_; } } } cached_has_bits = from._impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_mem_info_wmem() != 0) { + _this->_impl_.mem_info_wmem_ = from._impl_.mem_info_wmem_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_mem_info_fmem() != 0) { _this->_impl_.mem_info_fmem_ = from._impl_.mem_info_fmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_mem_info_tmem() != 0) { _this->_impl_.mem_info_tmem_ = from._impl_.mem_info_tmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_tcp_info_state() != 0) { _this->_impl_.tcp_info_state_ = from._impl_.tcp_info_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_tcp_info_ca_state() != 0) { _this->_impl_.tcp_info_ca_state_ = from._impl_.tcp_info_ca_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_tcp_info_retransmits() != 0) { _this->_impl_.tcp_info_retransmits_ = from._impl_.tcp_info_retransmits_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_tcp_info_probes() != 0) { _this->_impl_.tcp_info_probes_ = from._impl_.tcp_info_probes_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_tcp_info_backoff() != 0) { _this->_impl_.tcp_info_backoff_ = from._impl_.tcp_info_backoff_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_tcp_info_options() != 0) { _this->_impl_.tcp_info_options_ = from._impl_.tcp_info_options_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_tcp_info_send_scale() != 0) { _this->_impl_.tcp_info_send_scale_ = from._impl_.tcp_info_send_scale_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_rcv_scale() != 0) { _this->_impl_.tcp_info_rcv_scale_ = from._impl_.tcp_info_rcv_scale_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_delivery_rate_app_limited() != 0) { _this->_impl_.tcp_info_delivery_rate_app_limited_ = from._impl_.tcp_info_delivery_rate_app_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_tcp_info_fast_open_client_failed() != 0) { _this->_impl_.tcp_info_fast_open_client_failed_ = from._impl_.tcp_info_fast_open_client_failed_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_tcp_info_rto() != 0) { _this->_impl_.tcp_info_rto_ = from._impl_.tcp_info_rto_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_tcp_info_ato() != 0) { _this->_impl_.tcp_info_ato_ = from._impl_.tcp_info_ato_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_tcp_info_snd_mss() != 0) { _this->_impl_.tcp_info_snd_mss_ = from._impl_.tcp_info_snd_mss_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_tcp_info_rcv_mss() != 0) { _this->_impl_.tcp_info_rcv_mss_ = from._impl_.tcp_info_rcv_mss_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_tcp_info_unacked() != 0) { _this->_impl_.tcp_info_unacked_ = from._impl_.tcp_info_unacked_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_tcp_info_sacked() != 0) { _this->_impl_.tcp_info_sacked_ = from._impl_.tcp_info_sacked_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_tcp_info_lost() != 0) { _this->_impl_.tcp_info_lost_ = from._impl_.tcp_info_lost_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_tcp_info_retrans() != 0) { _this->_impl_.tcp_info_retrans_ = from._impl_.tcp_info_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_tcp_info_fackets() != 0) { _this->_impl_.tcp_info_fackets_ = from._impl_.tcp_info_fackets_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_tcp_info_last_data_sent() != 0) { _this->_impl_.tcp_info_last_data_sent_ = from._impl_.tcp_info_last_data_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_tcp_info_last_ack_sent() != 0) { _this->_impl_.tcp_info_last_ack_sent_ = from._impl_.tcp_info_last_ack_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_tcp_info_last_data_recv() != 0) { _this->_impl_.tcp_info_last_data_recv_ = from._impl_.tcp_info_last_data_recv_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_last_ack_recv() != 0) { _this->_impl_.tcp_info_last_ack_recv_ = from._impl_.tcp_info_last_ack_recv_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_pmtu() != 0) { _this->_impl_.tcp_info_pmtu_ = from._impl_.tcp_info_pmtu_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_rcv_ssthresh() != 0) { _this->_impl_.tcp_info_rcv_ssthresh_ = from._impl_.tcp_info_rcv_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_rtt() != 0) { _this->_impl_.tcp_info_rtt_ = from._impl_.tcp_info_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_rtt_var() != 0) { _this->_impl_.tcp_info_rtt_var_ = from._impl_.tcp_info_rtt_var_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_snd_ssthresh() != 0) { _this->_impl_.tcp_info_snd_ssthresh_ = from._impl_.tcp_info_snd_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_tcp_info_snd_cwnd() != 0) { _this->_impl_.tcp_info_snd_cwnd_ = from._impl_.tcp_info_snd_cwnd_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_tcp_info_adv_mss() != 0) { - _this->_impl_.tcp_info_adv_mss_ = from._impl_.tcp_info_adv_mss_; - } - } } cached_has_bits = from._impl_._has_bits_[3]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_tcp_info_adv_mss() != 0) { + _this->_impl_.tcp_info_adv_mss_ = from._impl_.tcp_info_adv_mss_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_tcp_info_reordering() != 0) { _this->_impl_.tcp_info_reordering_ = from._impl_.tcp_info_reordering_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_tcp_info_rcv_rtt() != 0) { _this->_impl_.tcp_info_rcv_rtt_ = from._impl_.tcp_info_rcv_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_tcp_info_rcv_space() != 0) { _this->_impl_.tcp_info_rcv_space_ = from._impl_.tcp_info_rcv_space_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (from._internal_tcp_info_total_retrans() != 0) { - _this->_impl_.tcp_info_total_retrans_ = from._impl_.tcp_info_total_retrans_; - } - } if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_tcp_info_pacing_rate() != 0) { _this->_impl_.tcp_info_pacing_rate_ = from._impl_.tcp_info_pacing_rate_; @@ -6171,47 +6204,47 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (from._internal_tcp_info_bytes_acked() != 0) { - _this->_impl_.tcp_info_bytes_acked_ = from._impl_.tcp_info_bytes_acked_; + if (from._internal_tcp_info_total_retrans() != 0) { + _this->_impl_.tcp_info_total_retrans_ = from._impl_.tcp_info_total_retrans_; } } if (CheckHasBit(cached_has_bits, 0x00000080U)) { - if (from._internal_tcp_info_bytes_received() != 0) { - _this->_impl_.tcp_info_bytes_received_ = from._impl_.tcp_info_bytes_received_; + if (from._internal_tcp_info_segs_out() != 0) { + _this->_impl_.tcp_info_segs_out_ = from._impl_.tcp_info_segs_out_; } } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (from._internal_tcp_info_segs_out() != 0) { - _this->_impl_.tcp_info_segs_out_ = from._impl_.tcp_info_segs_out_; + if (from._internal_tcp_info_bytes_acked() != 0) { + _this->_impl_.tcp_info_bytes_acked_ = from._impl_.tcp_info_bytes_acked_; } } if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (from._internal_tcp_info_bytes_received() != 0) { + _this->_impl_.tcp_info_bytes_received_ = from._impl_.tcp_info_bytes_received_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_segs_in() != 0) { _this->_impl_.tcp_info_segs_in_ = from._impl_.tcp_info_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_not_sent_bytes() != 0) { _this->_impl_.tcp_info_not_sent_bytes_ = from._impl_.tcp_info_not_sent_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_tcp_info_min_rtt() != 0) { _this->_impl_.tcp_info_min_rtt_ = from._impl_.tcp_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_tcp_info_data_segs_in() != 0) { _this->_impl_.tcp_info_data_segs_in_ = from._impl_.tcp_info_data_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (from._internal_tcp_info_data_segs_out() != 0) { - _this->_impl_.tcp_info_data_segs_out_ = from._impl_.tcp_info_data_segs_out_; - } - } if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_tcp_info_delivery_rate() != 0) { _this->_impl_.tcp_info_delivery_rate_ = from._impl_.tcp_info_delivery_rate_; @@ -6225,23 +6258,23 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (from._internal_tcp_info_rwnd_limited() != 0) { - _this->_impl_.tcp_info_rwnd_limited_ = from._impl_.tcp_info_rwnd_limited_; + if (from._internal_tcp_info_data_segs_out() != 0) { + _this->_impl_.tcp_info_data_segs_out_ = from._impl_.tcp_info_data_segs_out_; } } if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (from._internal_tcp_info_sndbuf_limited() != 0) { - _this->_impl_.tcp_info_sndbuf_limited_ = from._impl_.tcp_info_sndbuf_limited_; + if (from._internal_tcp_info_delivered() != 0) { + _this->_impl_.tcp_info_delivered_ = from._impl_.tcp_info_delivered_; } } if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (from._internal_tcp_info_delivered() != 0) { - _this->_impl_.tcp_info_delivered_ = from._impl_.tcp_info_delivered_; + if (from._internal_tcp_info_rwnd_limited() != 0) { + _this->_impl_.tcp_info_rwnd_limited_ = from._impl_.tcp_info_rwnd_limited_; } } if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (from._internal_tcp_info_delivered_ce() != 0) { - _this->_impl_.tcp_info_delivered_ce_ = from._impl_.tcp_info_delivered_ce_; + if (from._internal_tcp_info_sndbuf_limited() != 0) { + _this->_impl_.tcp_info_sndbuf_limited_ = from._impl_.tcp_info_sndbuf_limited_; } } if (CheckHasBit(cached_has_bits, 0x00100000U)) { @@ -6250,8 +6283,8 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (from._internal_tcp_info_bytes_retrans() != 0) { - _this->_impl_.tcp_info_bytes_retrans_ = from._impl_.tcp_info_bytes_retrans_; + if (from._internal_tcp_info_delivered_ce() != 0) { + _this->_impl_.tcp_info_delivered_ce_ = from._impl_.tcp_info_delivered_ce_; } } if (CheckHasBit(cached_has_bits, 0x00400000U)) { @@ -6260,206 +6293,211 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (from._internal_tcp_info_reord_seen() != 0) { - _this->_impl_.tcp_info_reord_seen_ = from._impl_.tcp_info_reord_seen_; + if (from._internal_tcp_info_bytes_retrans() != 0) { + _this->_impl_.tcp_info_bytes_retrans_ = from._impl_.tcp_info_bytes_retrans_; } } } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (from._internal_tcp_info_reord_seen() != 0) { + _this->_impl_.tcp_info_reord_seen_ = from._impl_.tcp_info_reord_seen_; + } + } + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_rcv_ooopack() != 0) { _this->_impl_.tcp_info_rcv_ooopack_ = from._impl_.tcp_info_rcv_ooopack_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_snd_wnd() != 0) { _this->_impl_.tcp_info_snd_wnd_ = from._impl_.tcp_info_snd_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_rcv_wnd() != 0) { _this->_impl_.tcp_info_rcv_wnd_ = from._impl_.tcp_info_rcv_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_rehash() != 0) { _this->_impl_.tcp_info_rehash_ = from._impl_.tcp_info_rehash_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_total_rto() != 0) { _this->_impl_.tcp_info_total_rto_ = from._impl_.tcp_info_total_rto_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_total_rto_recoveries() != 0) { _this->_impl_.tcp_info_total_rto_recoveries_ = from._impl_.tcp_info_total_rto_recoveries_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_tcp_info_total_rto_time() != 0) { _this->_impl_.tcp_info_total_rto_time_ = from._impl_.tcp_info_total_rto_time_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_congestion_algorithm_enum() != 0) { - _this->_impl_.congestion_algorithm_enum_ = from._impl_.congestion_algorithm_enum_; - } - } } cached_has_bits = from._impl_._has_bits_[4]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_congestion_algorithm_enum() != 0) { + _this->_impl_.congestion_algorithm_enum_ = from._impl_.congestion_algorithm_enum_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_type_of_service() != 0) { _this->_impl_.type_of_service_ = from._impl_.type_of_service_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_traffic_class() != 0) { _this->_impl_.traffic_class_ = from._impl_.traffic_class_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_sk_mem_info_rmem_alloc() != 0) { _this->_impl_.sk_mem_info_rmem_alloc_ = from._impl_.sk_mem_info_rmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_sk_mem_info_rcv_buf() != 0) { _this->_impl_.sk_mem_info_rcv_buf_ = from._impl_.sk_mem_info_rcv_buf_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_sk_mem_info_wmem_alloc() != 0) { _this->_impl_.sk_mem_info_wmem_alloc_ = from._impl_.sk_mem_info_wmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_sk_mem_info_snd_buf() != 0) { _this->_impl_.sk_mem_info_snd_buf_ = from._impl_.sk_mem_info_snd_buf_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_sk_mem_info_fwd_alloc() != 0) { _this->_impl_.sk_mem_info_fwd_alloc_ = from._impl_.sk_mem_info_fwd_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_sk_mem_info_wmem_queued() != 0) { _this->_impl_.sk_mem_info_wmem_queued_ = from._impl_.sk_mem_info_wmem_queued_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_sk_mem_info_optmem() != 0) { _this->_impl_.sk_mem_info_optmem_ = from._impl_.sk_mem_info_optmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_sk_mem_info_backlog() != 0) { _this->_impl_.sk_mem_info_backlog_ = from._impl_.sk_mem_info_backlog_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_sk_mem_info_drops() != 0) { _this->_impl_.sk_mem_info_drops_ = from._impl_.sk_mem_info_drops_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_shutdown_state() != 0) { _this->_impl_.shutdown_state_ = from._impl_.shutdown_state_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_vegas_info_enabled() != 0) { _this->_impl_.vegas_info_enabled_ = from._impl_.vegas_info_enabled_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_vegas_info_rtt_cnt() != 0) { _this->_impl_.vegas_info_rtt_cnt_ = from._impl_.vegas_info_rtt_cnt_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_vegas_info_rtt() != 0) { _this->_impl_.vegas_info_rtt_ = from._impl_.vegas_info_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_vegas_info_min_rtt() != 0) { _this->_impl_.vegas_info_min_rtt_ = from._impl_.vegas_info_min_rtt_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_dctcp_info_enabled() != 0) { _this->_impl_.dctcp_info_enabled_ = from._impl_.dctcp_info_enabled_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_dctcp_info_ce_state() != 0) { _this->_impl_.dctcp_info_ce_state_ = from._impl_.dctcp_info_ce_state_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_dctcp_info_alpha() != 0) { _this->_impl_.dctcp_info_alpha_ = from._impl_.dctcp_info_alpha_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_dctcp_info_ab_ecn() != 0) { _this->_impl_.dctcp_info_ab_ecn_ = from._impl_.dctcp_info_ab_ecn_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_dctcp_info_ab_tot() != 0) { _this->_impl_.dctcp_info_ab_tot_ = from._impl_.dctcp_info_ab_tot_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_bbr_info_bw_lo() != 0) { _this->_impl_.bbr_info_bw_lo_ = from._impl_.bbr_info_bw_lo_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_bbr_info_bw_hi() != 0) { _this->_impl_.bbr_info_bw_hi_ = from._impl_.bbr_info_bw_hi_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_bbr_info_min_rtt() != 0) { _this->_impl_.bbr_info_min_rtt_ = from._impl_.bbr_info_min_rtt_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x1f000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_bbr_info_pacing_gain() != 0) { _this->_impl_.bbr_info_pacing_gain_ = from._impl_.bbr_info_pacing_gain_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_bbr_info_cwnd_gain() != 0) { _this->_impl_.bbr_info_cwnd_gain_ = from._impl_.bbr_info_cwnd_gain_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_class_id() != 0) { _this->_impl_.class_id_ = from._impl_.class_id_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (from._internal_sock_opt() != 0) { - _this->_impl_.sock_opt_ = from._impl_.sock_opt_; - } - } if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_c_group() != 0) { _this->_impl_.c_group_ = from._impl_.c_group_; } } + if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (from._internal_sock_opt() != 0) { + _this->_impl_.sock_opt_ = from._impl_.sock_opt_; + } + } } _this->_impl_._has_bits_.Or(from._impl_._has_bits_); _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( @@ -6525,8 +6563,8 @@ void XtcpFlatRecord::InternalSwap(XtcpFlatRecord* PROTOBUF_RESTRICT PROTOBUF_NON ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_dest_network_owner_, &other->_impl_.inet_diag_msg_socket_dest_network_owner_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.congestion_algorithm_string_, &other->_impl_.congestion_algorithm_string_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_) - + sizeof(XtcpFlatRecord::_impl_.c_group_) + PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_) + + sizeof(XtcpFlatRecord::_impl_.sock_opt_) - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_)>( reinterpret_cast(&_impl_.netlinker_id_), reinterpret_cast(&other->_impl_.netlinker_id_)); diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h index 43f7c1e..880ae85 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h @@ -59,6 +59,8 @@ namespace xtcp_flat_record { namespace v1 { enum XtcpFlatRecord_CongestionAlgorithm : int; extern const uint32_t XtcpFlatRecord_CongestionAlgorithm_internal_data_[]; +enum XtcpFlatRecord_Locality : int; +extern const uint32_t XtcpFlatRecord_Locality_internal_data_[]; class Envelope; struct EnvelopeGlobalsTypeInternal; #ifndef PROTOBUF_MESSAGE_GLOBALS @@ -114,11 +116,56 @@ namespace protobuf { template <> internal::EnumTraitsT<::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm_internal_data_> internal::EnumTraitsImpl::value<::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm>; +template <> +internal::EnumTraitsT<::xtcp_flat_record::v1::XtcpFlatRecord_Locality_internal_data_> + internal::EnumTraitsImpl::value<::xtcp_flat_record::v1::XtcpFlatRecord_Locality>; } // namespace protobuf } // namespace google namespace xtcp_flat_record { namespace v1 { +enum XtcpFlatRecord_Locality : int { + XtcpFlatRecord_Locality_LOCALITY_UNSPECIFIED = 0, + XtcpFlatRecord_Locality_LOCALITY_SELF = 1, + XtcpFlatRecord_Locality_LOCALITY_LOCAL_SUBNET = 2, + XtcpFlatRecord_Locality_LOCALITY_REMOTE = 3, + XtcpFlatRecord_Locality_XtcpFlatRecord_Locality_INT_MIN_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::min(), + XtcpFlatRecord_Locality_XtcpFlatRecord_Locality_INT_MAX_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::max(), +}; + +extern const uint32_t XtcpFlatRecord_Locality_internal_data_[]; +inline constexpr XtcpFlatRecord_Locality XtcpFlatRecord_Locality_Locality_MIN = + static_cast(0); +inline constexpr XtcpFlatRecord_Locality XtcpFlatRecord_Locality_Locality_MAX = + static_cast(3); +[[nodiscard]] inline bool XtcpFlatRecord_Locality_IsValid(int value) { + return 0 <= value && value <= 3; +} +inline constexpr int XtcpFlatRecord_Locality_Locality_ARRAYSIZE = 3 + 1; +[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL +XtcpFlatRecord_Locality_descriptor(); +[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(XtcpFlatRecord_Locality) { + return XtcpFlatRecord_Locality_descriptor(); +} +template +[[nodiscard]] const ::std::string& XtcpFlatRecord_Locality_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to Locality_Name()."); + return XtcpFlatRecord_Locality_Name(static_cast(value)); +} +template <> +[[nodiscard]] inline const ::std::string& XtcpFlatRecord_Locality_Name(XtcpFlatRecord_Locality value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +[[nodiscard]] inline bool XtcpFlatRecord_Locality_Parse( + ::absl::string_view name, XtcpFlatRecord_Locality* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(XtcpFlatRecord_Locality_descriptor(), name, + value); +} enum XtcpFlatRecord_CongestionAlgorithm : int { XtcpFlatRecord_CongestionAlgorithm_CONGESTION_ALGORITHM_UNSPECIFIED = 0, XtcpFlatRecord_CongestionAlgorithm_CONGESTION_ALGORITHM_CUBIC = 1, @@ -318,6 +365,28 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const; // nested types ---------------------------------------------------- + using Locality = XtcpFlatRecord_Locality; + static constexpr Locality LOCALITY_UNSPECIFIED = XtcpFlatRecord_Locality_LOCALITY_UNSPECIFIED; + static constexpr Locality LOCALITY_SELF = XtcpFlatRecord_Locality_LOCALITY_SELF; + static constexpr Locality LOCALITY_LOCAL_SUBNET = XtcpFlatRecord_Locality_LOCALITY_LOCAL_SUBNET; + static constexpr Locality LOCALITY_REMOTE = XtcpFlatRecord_Locality_LOCALITY_REMOTE; + [[nodiscard]] static inline bool Locality_IsValid(int value) { + return XtcpFlatRecord_Locality_IsValid(value); + } + static constexpr Locality Locality_MIN = XtcpFlatRecord_Locality_Locality_MIN; + static constexpr Locality Locality_MAX = XtcpFlatRecord_Locality_Locality_MAX; + static constexpr int Locality_ARRAYSIZE = XtcpFlatRecord_Locality_Locality_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Locality_descriptor() { + return XtcpFlatRecord_Locality_descriptor(); + } + template + [[nodiscard]] static inline const ::std::string& Locality_Name(T value) { + return XtcpFlatRecord_Locality_Name(value); + } + [[nodiscard]] static inline bool Locality_Parse( + ::absl::string_view name, Locality* PROTOBUF_NONNULL value) { + return XtcpFlatRecord_Locality_Parse(name, value); + } using CongestionAlgorithm = XtcpFlatRecord_CongestionAlgorithm; static constexpr CongestionAlgorithm CONGESTION_ALGORITHM_UNSPECIFIED = XtcpFlatRecord_CongestionAlgorithm_CONGESTION_ALGORITHM_UNSPECIFIED; static constexpr CongestionAlgorithm CONGESTION_ALGORITHM_CUBIC = XtcpFlatRecord_CongestionAlgorithm_CONGESTION_ALGORITHM_CUBIC; @@ -409,6 +478,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kInetDiagMsgWqueueFieldNumber = 1015, kInetDiagMsgUidFieldNumber = 1016, kInetDiagMsgInodeFieldNumber = 1017, + kInetDiagMsgSocketDestLocalityFieldNumber = 1019, kMemInfoRmemFieldNumber = 1101, kMemInfoWmemFieldNumber = 1102, kMemInfoFmemFieldNumber = 1103, @@ -446,26 +516,26 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kTcpInfoReorderingFieldNumber = 1235, kTcpInfoRcvRttFieldNumber = 1236, kTcpInfoRcvSpaceFieldNumber = 1237, - kTcpInfoTotalRetransFieldNumber = 1238, kTcpInfoPacingRateFieldNumber = 1239, kTcpInfoMaxPacingRateFieldNumber = 1240, + kTcpInfoTotalRetransFieldNumber = 1238, + kTcpInfoSegsOutFieldNumber = 1243, kTcpInfoBytesAckedFieldNumber = 1241, kTcpInfoBytesReceivedFieldNumber = 1242, - kTcpInfoSegsOutFieldNumber = 1243, kTcpInfoSegsInFieldNumber = 1244, kTcpInfoNotSentBytesFieldNumber = 1245, kTcpInfoMinRttFieldNumber = 1246, kTcpInfoDataSegsInFieldNumber = 1247, - kTcpInfoDataSegsOutFieldNumber = 1248, kTcpInfoDeliveryRateFieldNumber = 1249, kTcpInfoBusyTimeFieldNumber = 1250, + kTcpInfoDataSegsOutFieldNumber = 1248, + kTcpInfoDeliveredFieldNumber = 1253, kTcpInfoRwndLimitedFieldNumber = 1251, kTcpInfoSndbufLimitedFieldNumber = 1252, - kTcpInfoDeliveredFieldNumber = 1253, - kTcpInfoDeliveredCeFieldNumber = 1254, kTcpInfoBytesSentFieldNumber = 1255, - kTcpInfoBytesRetransFieldNumber = 1256, + kTcpInfoDeliveredCeFieldNumber = 1254, kTcpInfoDsackDupsFieldNumber = 1257, + kTcpInfoBytesRetransFieldNumber = 1256, kTcpInfoReordSeenFieldNumber = 1258, kTcpInfoRcvOoopackFieldNumber = 1259, kTcpInfoSndWndFieldNumber = 1260, @@ -502,8 +572,8 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kBbrInfoPacingGainFieldNumber = 1904, kBbrInfoCwndGainFieldNumber = 1905, kClassIdFieldNumber = 2001, - kSockOptFieldNumber = 2002, kCGroupFieldNumber = 2103, + kSockOptFieldNumber = 2002, }; // string daemon_version = 2 [json_name = "daemonVersion"]; void clear_daemon_version() ; @@ -1294,6 +1364,16 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_inet_diag_msg_inode() const; void _internal_set_inet_diag_msg_inode(::uint32_t value); + public: + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; + void clear_inet_diag_msg_socket_dest_locality() ; + [[nodiscard]] ::xtcp_flat_record::v1::XtcpFlatRecord_Locality inet_diag_msg_socket_dest_locality() const; + void set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); + + private: + ::xtcp_flat_record::v1::XtcpFlatRecord_Locality _internal_inet_diag_msg_socket_dest_locality() const; + void _internal_set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); + public: // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; void clear_mem_info_rmem() ; @@ -1664,16 +1744,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_tcp_info_rcv_space() const; void _internal_set_tcp_info_rcv_space(::uint32_t value); - public: - // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - void clear_tcp_info_total_retrans() ; - [[nodiscard]] ::uint32_t tcp_info_total_retrans() const; - void set_tcp_info_total_retrans(::uint32_t value); - - private: - ::uint32_t _internal_tcp_info_total_retrans() const; - void _internal_set_tcp_info_total_retrans(::uint32_t value); - public: // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; void clear_tcp_info_pacing_rate() ; @@ -1694,6 +1764,26 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_tcp_info_max_pacing_rate() const; void _internal_set_tcp_info_max_pacing_rate(::uint64_t value); + public: + // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; + void clear_tcp_info_total_retrans() ; + [[nodiscard]] ::uint32_t tcp_info_total_retrans() const; + void set_tcp_info_total_retrans(::uint32_t value); + + private: + ::uint32_t _internal_tcp_info_total_retrans() const; + void _internal_set_tcp_info_total_retrans(::uint32_t value); + + public: + // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; + void clear_tcp_info_segs_out() ; + [[nodiscard]] ::uint32_t tcp_info_segs_out() const; + void set_tcp_info_segs_out(::uint32_t value); + + private: + ::uint32_t _internal_tcp_info_segs_out() const; + void _internal_set_tcp_info_segs_out(::uint32_t value); + public: // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; void clear_tcp_info_bytes_acked() ; @@ -1714,16 +1804,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_tcp_info_bytes_received() const; void _internal_set_tcp_info_bytes_received(::uint64_t value); - public: - // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - void clear_tcp_info_segs_out() ; - [[nodiscard]] ::uint32_t tcp_info_segs_out() const; - void set_tcp_info_segs_out(::uint32_t value); - - private: - ::uint32_t _internal_tcp_info_segs_out() const; - void _internal_set_tcp_info_segs_out(::uint32_t value); - public: // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; void clear_tcp_info_segs_in() ; @@ -1764,16 +1844,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_tcp_info_data_segs_in() const; void _internal_set_tcp_info_data_segs_in(::uint32_t value); - public: - // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - void clear_tcp_info_data_segs_out() ; - [[nodiscard]] ::uint32_t tcp_info_data_segs_out() const; - void set_tcp_info_data_segs_out(::uint32_t value); - - private: - ::uint32_t _internal_tcp_info_data_segs_out() const; - void _internal_set_tcp_info_data_segs_out(::uint32_t value); - public: // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; void clear_tcp_info_delivery_rate() ; @@ -1794,6 +1864,26 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_tcp_info_busy_time() const; void _internal_set_tcp_info_busy_time(::uint64_t value); + public: + // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; + void clear_tcp_info_data_segs_out() ; + [[nodiscard]] ::uint32_t tcp_info_data_segs_out() const; + void set_tcp_info_data_segs_out(::uint32_t value); + + private: + ::uint32_t _internal_tcp_info_data_segs_out() const; + void _internal_set_tcp_info_data_segs_out(::uint32_t value); + + public: + // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; + void clear_tcp_info_delivered() ; + [[nodiscard]] ::uint32_t tcp_info_delivered() const; + void set_tcp_info_delivered(::uint32_t value); + + private: + ::uint32_t _internal_tcp_info_delivered() const; + void _internal_set_tcp_info_delivered(::uint32_t value); + public: // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; void clear_tcp_info_rwnd_limited() ; @@ -1815,14 +1905,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_sndbuf_limited(::uint64_t value); public: - // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - void clear_tcp_info_delivered() ; - [[nodiscard]] ::uint32_t tcp_info_delivered() const; - void set_tcp_info_delivered(::uint32_t value); + // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; + void clear_tcp_info_bytes_sent() ; + [[nodiscard]] ::uint64_t tcp_info_bytes_sent() const; + void set_tcp_info_bytes_sent(::uint64_t value); private: - ::uint32_t _internal_tcp_info_delivered() const; - void _internal_set_tcp_info_delivered(::uint32_t value); + ::uint64_t _internal_tcp_info_bytes_sent() const; + void _internal_set_tcp_info_bytes_sent(::uint64_t value); public: // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; @@ -1835,14 +1925,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_delivered_ce(::uint32_t value); public: - // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - void clear_tcp_info_bytes_sent() ; - [[nodiscard]] ::uint64_t tcp_info_bytes_sent() const; - void set_tcp_info_bytes_sent(::uint64_t value); + // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; + void clear_tcp_info_dsack_dups() ; + [[nodiscard]] ::uint32_t tcp_info_dsack_dups() const; + void set_tcp_info_dsack_dups(::uint32_t value); private: - ::uint64_t _internal_tcp_info_bytes_sent() const; - void _internal_set_tcp_info_bytes_sent(::uint64_t value); + ::uint32_t _internal_tcp_info_dsack_dups() const; + void _internal_set_tcp_info_dsack_dups(::uint32_t value); public: // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; @@ -1854,16 +1944,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_tcp_info_bytes_retrans() const; void _internal_set_tcp_info_bytes_retrans(::uint64_t value); - public: - // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - void clear_tcp_info_dsack_dups() ; - [[nodiscard]] ::uint32_t tcp_info_dsack_dups() const; - void set_tcp_info_dsack_dups(::uint32_t value); - - private: - ::uint32_t _internal_tcp_info_dsack_dups() const; - void _internal_set_tcp_info_dsack_dups(::uint32_t value); - public: // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; void clear_tcp_info_reord_seen() ; @@ -2224,16 +2304,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_class_id() const; void _internal_set_class_id(::uint32_t value); - public: - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - void clear_sock_opt() ; - [[nodiscard]] ::uint32_t sock_opt() const; - void set_sock_opt(::uint32_t value); - - private: - ::uint32_t _internal_sock_opt() const; - void _internal_set_sock_opt(::uint32_t value); - public: // uint64 c_group = 2103 [json_name = "cGroup"]; void clear_c_group() ; @@ -2244,12 +2314,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_c_group() const; void _internal_set_c_group(::uint64_t value); + public: + // uint32 sock_opt = 2002 [json_name = "sockOpt"]; + void clear_sock_opt() ; + [[nodiscard]] ::uint32_t sock_opt() const; + void set_sock_opt(::uint32_t value); + + private: + ::uint32_t _internal_sock_opt() const; + void _internal_set_sock_opt(::uint32_t value); + public: // @@protoc_insertion_point(class_scope:xtcp_flat_record.v1.XtcpFlatRecord) private: class _Internal; using ParseTableT_ = - ::google::protobuf::internal::TcParseTable<5, 157, + ::google::protobuf::internal::TcParseTable<5, 158, 0, 766, 103>; static constexpr ParseTableT_ InternalGenerateParseTable_( @@ -2340,6 +2420,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t inet_diag_msg_wqueue_; ::uint32_t inet_diag_msg_uid_; ::uint32_t inet_diag_msg_inode_; + int inet_diag_msg_socket_dest_locality_; ::uint32_t mem_info_rmem_; ::uint32_t mem_info_wmem_; ::uint32_t mem_info_fmem_; @@ -2377,26 +2458,26 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t tcp_info_reordering_; ::uint32_t tcp_info_rcv_rtt_; ::uint32_t tcp_info_rcv_space_; - ::uint32_t tcp_info_total_retrans_; ::uint64_t tcp_info_pacing_rate_; ::uint64_t tcp_info_max_pacing_rate_; + ::uint32_t tcp_info_total_retrans_; + ::uint32_t tcp_info_segs_out_; ::uint64_t tcp_info_bytes_acked_; ::uint64_t tcp_info_bytes_received_; - ::uint32_t tcp_info_segs_out_; ::uint32_t tcp_info_segs_in_; ::uint32_t tcp_info_not_sent_bytes_; ::uint32_t tcp_info_min_rtt_; ::uint32_t tcp_info_data_segs_in_; - ::uint32_t tcp_info_data_segs_out_; ::uint64_t tcp_info_delivery_rate_; ::uint64_t tcp_info_busy_time_; + ::uint32_t tcp_info_data_segs_out_; + ::uint32_t tcp_info_delivered_; ::uint64_t tcp_info_rwnd_limited_; ::uint64_t tcp_info_sndbuf_limited_; - ::uint32_t tcp_info_delivered_; - ::uint32_t tcp_info_delivered_ce_; ::uint64_t tcp_info_bytes_sent_; - ::uint64_t tcp_info_bytes_retrans_; + ::uint32_t tcp_info_delivered_ce_; ::uint32_t tcp_info_dsack_dups_; + ::uint64_t tcp_info_bytes_retrans_; ::uint32_t tcp_info_reord_seen_; ::uint32_t tcp_info_rcv_ooopack_; ::uint32_t tcp_info_snd_wnd_; @@ -2433,8 +2514,8 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t bbr_info_pacing_gain_; ::uint32_t bbr_info_cwnd_gain_; ::uint32_t class_id_; - ::uint32_t sock_opt_; ::uint64_t c_group_; + ::uint32_t sock_opt_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; @@ -6202,11 +6283,35 @@ inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_dest_network_owne // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) } +// .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_locality() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_dest_locality_ = 0; + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); +} +inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::inet_diag_msg_socket_dest_locality() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality) + return _internal_inet_diag_msg_socket_dest_locality(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { + _internal_set_inet_diag_msg_socket_dest_locality(value); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality) +} +inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_locality() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::xtcp_flat_record::v1::XtcpFlatRecord_Locality>(_impl_.inet_diag_msg_socket_dest_locality_); +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_dest_locality_ = value; +} + // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; inline void XtcpFlatRecord::clear_mem_info_rmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_rmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) @@ -6214,7 +6319,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { } inline void XtcpFlatRecord::set_mem_info_rmem(::uint32_t value) { _internal_set_mem_info_rmem(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_rmem() const { @@ -6230,7 +6335,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_rmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_wmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_wmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) @@ -6238,7 +6343,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { } inline void XtcpFlatRecord::set_mem_info_wmem(::uint32_t value) { _internal_set_mem_info_wmem(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_wmem() const { @@ -6254,7 +6359,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_wmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_fmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_fmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000001U); + ClearHasBit(_impl_._has_bits_[2], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) @@ -6262,7 +6367,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { } inline void XtcpFlatRecord::set_mem_info_fmem(::uint32_t value) { _internal_set_mem_info_fmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000001U); + SetHasBit(_impl_._has_bits_[2], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_fmem() const { @@ -6278,7 +6383,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_fmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_tmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_tmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000002U); + ClearHasBit(_impl_._has_bits_[2], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) @@ -6286,7 +6391,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { } inline void XtcpFlatRecord::set_mem_info_tmem(::uint32_t value) { _internal_set_mem_info_tmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000002U); + SetHasBit(_impl_._has_bits_[2], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_tmem() const { @@ -6302,7 +6407,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_tmem(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000004U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) @@ -6310,7 +6415,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { } inline void XtcpFlatRecord::set_tcp_info_state(::uint32_t value) { _internal_set_tcp_info_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000004U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_state() const { @@ -6326,7 +6431,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ca_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ca_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000008U); + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) @@ -6334,7 +6439,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { } inline void XtcpFlatRecord::set_tcp_info_ca_state(::uint32_t value) { _internal_set_tcp_info_ca_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000008U); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ca_state() const { @@ -6350,7 +6455,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ca_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retransmits() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retransmits_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000010U); + ClearHasBit(_impl_._has_bits_[2], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) @@ -6358,7 +6463,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { } inline void XtcpFlatRecord::set_tcp_info_retransmits(::uint32_t value) { _internal_set_tcp_info_retransmits(value); - SetHasBit(_impl_._has_bits_[2], 0x00000010U); + SetHasBit(_impl_._has_bits_[2], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retransmits() const { @@ -6374,7 +6479,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retransmits(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_probes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_probes_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000020U); + ClearHasBit(_impl_._has_bits_[2], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) @@ -6382,7 +6487,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { } inline void XtcpFlatRecord::set_tcp_info_probes(::uint32_t value) { _internal_set_tcp_info_probes(value); - SetHasBit(_impl_._has_bits_[2], 0x00000020U); + SetHasBit(_impl_._has_bits_[2], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_probes() const { @@ -6398,7 +6503,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_probes(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_backoff() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_backoff_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000040U); + ClearHasBit(_impl_._has_bits_[2], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) @@ -6406,7 +6511,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { } inline void XtcpFlatRecord::set_tcp_info_backoff(::uint32_t value) { _internal_set_tcp_info_backoff(value); - SetHasBit(_impl_._has_bits_[2], 0x00000040U); + SetHasBit(_impl_._has_bits_[2], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_backoff() const { @@ -6422,7 +6527,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_backoff(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_options() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_options_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000080U); + ClearHasBit(_impl_._has_bits_[2], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) @@ -6430,7 +6535,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { } inline void XtcpFlatRecord::set_tcp_info_options(::uint32_t value) { _internal_set_tcp_info_options(value); - SetHasBit(_impl_._has_bits_[2], 0x00000080U); + SetHasBit(_impl_._has_bits_[2], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_options() const { @@ -6446,7 +6551,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_options(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_send_scale() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_send_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000100U); + ClearHasBit(_impl_._has_bits_[2], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::tcp_info_send_scale() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) @@ -6454,7 +6559,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_send_scale() const { } inline void XtcpFlatRecord::set_tcp_info_send_scale(::uint32_t value) { _internal_set_tcp_info_send_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000100U); + SetHasBit(_impl_._has_bits_[2], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_send_scale() const { @@ -6470,7 +6575,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_send_scale(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_scale() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000200U); + ClearHasBit(_impl_._has_bits_[2], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_scale() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) @@ -6478,7 +6583,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_scale() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_scale(::uint32_t value) { _internal_set_tcp_info_rcv_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000200U); + SetHasBit(_impl_._has_bits_[2], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_scale() const { @@ -6494,7 +6599,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_scale(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_delivery_rate_app_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivery_rate_app_limited_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000400U); + ClearHasBit(_impl_._has_bits_[2], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) @@ -6502,7 +6607,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { } inline void XtcpFlatRecord::set_tcp_info_delivery_rate_app_limited(::uint32_t value) { _internal_set_tcp_info_delivery_rate_app_limited(value); - SetHasBit(_impl_._has_bits_[2], 0x00000400U); + SetHasBit(_impl_._has_bits_[2], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivery_rate_app_limited() const { @@ -6518,7 +6623,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivery_rate_app_limited(::u inline void XtcpFlatRecord::clear_tcp_info_fast_open_client_failed() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_fast_open_client_failed_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000800U); + ClearHasBit(_impl_._has_bits_[2], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_fast_open_client_failed() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) @@ -6526,7 +6631,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_fast_open_client_failed() const { } inline void XtcpFlatRecord::set_tcp_info_fast_open_client_failed(::uint32_t value) { _internal_set_tcp_info_fast_open_client_failed(value); - SetHasBit(_impl_._has_bits_[2], 0x00000800U); + SetHasBit(_impl_._has_bits_[2], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fast_open_client_failed() const { @@ -6542,7 +6647,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_fast_open_client_failed(::uin inline void XtcpFlatRecord::clear_tcp_info_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00001000U); + ClearHasBit(_impl_._has_bits_[2], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) @@ -6550,7 +6655,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { } inline void XtcpFlatRecord::set_tcp_info_rto(::uint32_t value) { _internal_set_tcp_info_rto(value); - SetHasBit(_impl_._has_bits_[2], 0x00001000U); + SetHasBit(_impl_._has_bits_[2], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rto() const { @@ -6566,7 +6671,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ato() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ato_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00002000U); + ClearHasBit(_impl_._has_bits_[2], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) @@ -6574,7 +6679,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { } inline void XtcpFlatRecord::set_tcp_info_ato(::uint32_t value) { _internal_set_tcp_info_ato(value); - SetHasBit(_impl_._has_bits_[2], 0x00002000U); + SetHasBit(_impl_._has_bits_[2], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ato() const { @@ -6590,7 +6695,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ato(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_snd_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00004000U); + ClearHasBit(_impl_._has_bits_[2], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) @@ -6598,7 +6703,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { } inline void XtcpFlatRecord::set_tcp_info_snd_mss(::uint32_t value) { _internal_set_tcp_info_snd_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00004000U); + SetHasBit(_impl_._has_bits_[2], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_mss() const { @@ -6614,7 +6719,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00008000U); + ClearHasBit(_impl_._has_bits_[2], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) @@ -6622,7 +6727,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_mss(::uint32_t value) { _internal_set_tcp_info_rcv_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00008000U); + SetHasBit(_impl_._has_bits_[2], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_mss() const { @@ -6638,7 +6743,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_unacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_unacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00010000U); + ClearHasBit(_impl_._has_bits_[2], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) @@ -6646,7 +6751,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { } inline void XtcpFlatRecord::set_tcp_info_unacked(::uint32_t value) { _internal_set_tcp_info_unacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00010000U); + SetHasBit(_impl_._has_bits_[2], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_unacked() const { @@ -6662,7 +6767,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_unacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_sacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00020000U); + ClearHasBit(_impl_._has_bits_[2], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) @@ -6670,7 +6775,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { } inline void XtcpFlatRecord::set_tcp_info_sacked(::uint32_t value) { _internal_set_tcp_info_sacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00020000U); + SetHasBit(_impl_._has_bits_[2], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_sacked() const { @@ -6686,7 +6791,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_lost() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_lost_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00040000U); + ClearHasBit(_impl_._has_bits_[2], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) @@ -6694,7 +6799,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { } inline void XtcpFlatRecord::set_tcp_info_lost(::uint32_t value) { _internal_set_tcp_info_lost(value); - SetHasBit(_impl_._has_bits_[2], 0x00040000U); + SetHasBit(_impl_._has_bits_[2], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_lost() const { @@ -6710,7 +6815,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_lost(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00080000U); + ClearHasBit(_impl_._has_bits_[2], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) @@ -6718,7 +6823,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_retrans(::uint32_t value) { _internal_set_tcp_info_retrans(value); - SetHasBit(_impl_._has_bits_[2], 0x00080000U); + SetHasBit(_impl_._has_bits_[2], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retrans() const { @@ -6734,7 +6839,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retrans(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_fackets() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_fackets_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00100000U); + ClearHasBit(_impl_._has_bits_[2], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) @@ -6742,7 +6847,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { } inline void XtcpFlatRecord::set_tcp_info_fackets(::uint32_t value) { _internal_set_tcp_info_fackets(value); - SetHasBit(_impl_._has_bits_[2], 0x00100000U); + SetHasBit(_impl_._has_bits_[2], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fackets() const { @@ -6758,7 +6863,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_fackets(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_last_data_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00200000U); + ClearHasBit(_impl_._has_bits_[2], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) @@ -6766,7 +6871,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_sent(::uint32_t value) { _internal_set_tcp_info_last_data_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00200000U); + SetHasBit(_impl_._has_bits_[2], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_sent() const { @@ -6782,7 +6887,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_sent(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00400000U); + ClearHasBit(_impl_._has_bits_[2], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) @@ -6790,7 +6895,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_sent(::uint32_t value) { _internal_set_tcp_info_last_ack_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00400000U); + SetHasBit(_impl_._has_bits_[2], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_sent() const { @@ -6806,7 +6911,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_sent(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_last_data_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00800000U); + ClearHasBit(_impl_._has_bits_[2], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) @@ -6814,7 +6919,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_recv(::uint32_t value) { _internal_set_tcp_info_last_data_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x00800000U); + SetHasBit(_impl_._has_bits_[2], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_recv() const { @@ -6830,7 +6935,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_recv(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x01000000U); + ClearHasBit(_impl_._has_bits_[2], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) @@ -6838,7 +6943,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_recv(::uint32_t value) { _internal_set_tcp_info_last_ack_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x01000000U); + SetHasBit(_impl_._has_bits_[2], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_recv() const { @@ -6854,7 +6959,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_recv(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_pmtu() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_pmtu_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x02000000U); + ClearHasBit(_impl_._has_bits_[2], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) @@ -6862,7 +6967,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { } inline void XtcpFlatRecord::set_tcp_info_pmtu(::uint32_t value) { _internal_set_tcp_info_pmtu(value); - SetHasBit(_impl_._has_bits_[2], 0x02000000U); + SetHasBit(_impl_._has_bits_[2], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_pmtu() const { @@ -6878,7 +6983,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_pmtu(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x04000000U); + ClearHasBit(_impl_._has_bits_[2], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) @@ -6886,7 +6991,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ssthresh(::uint32_t value) { _internal_set_tcp_info_rcv_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x04000000U); + SetHasBit(_impl_._has_bits_[2], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ssthresh() const { @@ -6902,7 +7007,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x08000000U); + ClearHasBit(_impl_._has_bits_[2], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) @@ -6910,7 +7015,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rtt(::uint32_t value) { _internal_set_tcp_info_rtt(value); - SetHasBit(_impl_._has_bits_[2], 0x08000000U); + SetHasBit(_impl_._has_bits_[2], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt() const { @@ -6926,7 +7031,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rtt_var() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rtt_var_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x10000000U); + ClearHasBit(_impl_._has_bits_[2], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rtt_var() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) @@ -6934,7 +7039,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rtt_var() const { } inline void XtcpFlatRecord::set_tcp_info_rtt_var(::uint32_t value) { _internal_set_tcp_info_rtt_var(value); - SetHasBit(_impl_._has_bits_[2], 0x10000000U); + SetHasBit(_impl_._has_bits_[2], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt_var() const { @@ -6950,7 +7055,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rtt_var(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_snd_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x20000000U); + ClearHasBit(_impl_._has_bits_[2], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) @@ -6958,7 +7063,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_snd_ssthresh(::uint32_t value) { _internal_set_tcp_info_snd_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x20000000U); + SetHasBit(_impl_._has_bits_[2], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_ssthresh() const { @@ -6974,7 +7079,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_snd_cwnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_cwnd_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x40000000U); + ClearHasBit(_impl_._has_bits_[2], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) @@ -6982,7 +7087,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_cwnd(::uint32_t value) { _internal_set_tcp_info_snd_cwnd(value); - SetHasBit(_impl_._has_bits_[2], 0x40000000U); + SetHasBit(_impl_._has_bits_[2], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_cwnd() const { @@ -6998,7 +7103,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_cwnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_adv_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_adv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x80000000U); + ClearHasBit(_impl_._has_bits_[3], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::tcp_info_adv_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) @@ -7006,7 +7111,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_adv_mss() const { } inline void XtcpFlatRecord::set_tcp_info_adv_mss(::uint32_t value) { _internal_set_tcp_info_adv_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x80000000U); + SetHasBit(_impl_._has_bits_[3], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_adv_mss() const { @@ -7022,7 +7127,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_adv_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_reordering() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reordering_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000001U); + ClearHasBit(_impl_._has_bits_[3], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) @@ -7030,7 +7135,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { } inline void XtcpFlatRecord::set_tcp_info_reordering(::uint32_t value) { _internal_set_tcp_info_reordering(value); - SetHasBit(_impl_._has_bits_[3], 0x00000001U); + SetHasBit(_impl_._has_bits_[3], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reordering() const { @@ -7046,7 +7151,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reordering(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000002U); + ClearHasBit(_impl_._has_bits_[3], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) @@ -7054,7 +7159,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_rtt(::uint32_t value) { _internal_set_tcp_info_rcv_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00000002U); + SetHasBit(_impl_._has_bits_[3], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_rtt() const { @@ -7070,7 +7175,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_space() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_space_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000004U); + ClearHasBit(_impl_._has_bits_[3], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) @@ -7078,7 +7183,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_space(::uint32_t value) { _internal_set_tcp_info_rcv_space(value); - SetHasBit(_impl_._has_bits_[3], 0x00000004U); + SetHasBit(_impl_._has_bits_[3], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_space() const { @@ -7094,7 +7199,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_space(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000008U); + ClearHasBit(_impl_._has_bits_[3], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) @@ -7102,7 +7207,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_total_retrans(::uint32_t value) { _internal_set_tcp_info_total_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00000008U); + SetHasBit(_impl_._has_bits_[3], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_retrans() const { @@ -7166,7 +7271,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_max_pacing_rate(::uint64_t va inline void XtcpFlatRecord::clear_tcp_info_bytes_acked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_acked_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000040U); + ClearHasBit(_impl_._has_bits_[3], 0x00000100U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) @@ -7174,7 +7279,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_acked(::uint64_t value) { _internal_set_tcp_info_bytes_acked(value); - SetHasBit(_impl_._has_bits_[3], 0x00000040U); + SetHasBit(_impl_._has_bits_[3], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_acked() const { @@ -7190,7 +7295,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_acked(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_received() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_received_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000080U); + ClearHasBit(_impl_._has_bits_[3], 0x00000200U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) @@ -7198,7 +7303,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_received(::uint64_t value) { _internal_set_tcp_info_bytes_received(value); - SetHasBit(_impl_._has_bits_[3], 0x00000080U); + SetHasBit(_impl_._has_bits_[3], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_received() const { @@ -7214,7 +7319,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_received(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000100U); + ClearHasBit(_impl_._has_bits_[3], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) @@ -7222,7 +7327,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_segs_out(::uint32_t value) { _internal_set_tcp_info_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00000100U); + SetHasBit(_impl_._has_bits_[3], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_out() const { @@ -7238,7 +7343,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_out(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000200U); + ClearHasBit(_impl_._has_bits_[3], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) @@ -7246,7 +7351,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_segs_in(::uint32_t value) { _internal_set_tcp_info_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00000200U); + SetHasBit(_impl_._has_bits_[3], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_in() const { @@ -7262,7 +7367,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_in(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_not_sent_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_not_sent_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000400U); + ClearHasBit(_impl_._has_bits_[3], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::tcp_info_not_sent_bytes() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) @@ -7270,7 +7375,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_not_sent_bytes() const { } inline void XtcpFlatRecord::set_tcp_info_not_sent_bytes(::uint32_t value) { _internal_set_tcp_info_not_sent_bytes(value); - SetHasBit(_impl_._has_bits_[3], 0x00000400U); + SetHasBit(_impl_._has_bits_[3], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_not_sent_bytes() const { @@ -7286,7 +7391,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_not_sent_bytes(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000800U); + ClearHasBit(_impl_._has_bits_[3], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) @@ -7294,7 +7399,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_min_rtt(::uint32_t value) { _internal_set_tcp_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00000800U); + SetHasBit(_impl_._has_bits_[3], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_min_rtt() const { @@ -7310,7 +7415,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_data_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00001000U); + ClearHasBit(_impl_._has_bits_[3], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) @@ -7318,7 +7423,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_in(::uint32_t value) { _internal_set_tcp_info_data_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00001000U); + SetHasBit(_impl_._has_bits_[3], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_in() const { @@ -7334,7 +7439,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_data_segs_in(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_data_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00002000U); + ClearHasBit(_impl_._has_bits_[3], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) @@ -7342,7 +7447,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_out(::uint32_t value) { _internal_set_tcp_info_data_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00002000U); + SetHasBit(_impl_._has_bits_[3], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_out() const { @@ -7406,7 +7511,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_busy_time(::uint64_t value) { inline void XtcpFlatRecord::clear_tcp_info_rwnd_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rwnd_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00010000U); + ClearHasBit(_impl_._has_bits_[3], 0x00040000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) @@ -7414,7 +7519,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { } inline void XtcpFlatRecord::set_tcp_info_rwnd_limited(::uint64_t value) { _internal_set_tcp_info_rwnd_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00010000U); + SetHasBit(_impl_._has_bits_[3], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_rwnd_limited() const { @@ -7430,7 +7535,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rwnd_limited(::uint64_t value inline void XtcpFlatRecord::clear_tcp_info_sndbuf_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sndbuf_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00020000U); + ClearHasBit(_impl_._has_bits_[3], 0x00080000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) @@ -7438,7 +7543,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { } inline void XtcpFlatRecord::set_tcp_info_sndbuf_limited(::uint64_t value) { _internal_set_tcp_info_sndbuf_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00020000U); + SetHasBit(_impl_._has_bits_[3], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_sndbuf_limited() const { @@ -7454,7 +7559,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sndbuf_limited(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_delivered() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00040000U); + ClearHasBit(_impl_._has_bits_[3], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) @@ -7462,7 +7567,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { } inline void XtcpFlatRecord::set_tcp_info_delivered(::uint32_t value) { _internal_set_tcp_info_delivered(value); - SetHasBit(_impl_._has_bits_[3], 0x00040000U); + SetHasBit(_impl_._has_bits_[3], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered() const { @@ -7478,7 +7583,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivered(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_delivered_ce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ce_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00080000U); + ClearHasBit(_impl_._has_bits_[3], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) @@ -7486,7 +7591,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { } inline void XtcpFlatRecord::set_tcp_info_delivered_ce(::uint32_t value) { _internal_set_tcp_info_delivered_ce(value); - SetHasBit(_impl_._has_bits_[3], 0x00080000U); + SetHasBit(_impl_._has_bits_[3], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered_ce() const { @@ -7526,7 +7631,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_sent(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_retrans_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00200000U); + ClearHasBit(_impl_._has_bits_[3], 0x00800000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) @@ -7534,7 +7639,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_retrans(::uint64_t value) { _internal_set_tcp_info_bytes_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00200000U); + SetHasBit(_impl_._has_bits_[3], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_retrans() const { @@ -7574,7 +7679,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_dsack_dups(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_reord_seen() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reord_seen_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00800000U); + ClearHasBit(_impl_._has_bits_[3], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) @@ -7582,7 +7687,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { } inline void XtcpFlatRecord::set_tcp_info_reord_seen(::uint32_t value) { _internal_set_tcp_info_reord_seen(value); - SetHasBit(_impl_._has_bits_[3], 0x00800000U); + SetHasBit(_impl_._has_bits_[3], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reord_seen() const { @@ -7598,7 +7703,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reord_seen(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_ooopack() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ooopack_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x01000000U); + ClearHasBit(_impl_._has_bits_[3], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) @@ -7606,7 +7711,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ooopack(::uint32_t value) { _internal_set_tcp_info_rcv_ooopack(value); - SetHasBit(_impl_._has_bits_[3], 0x01000000U); + SetHasBit(_impl_._has_bits_[3], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ooopack() const { @@ -7622,7 +7727,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ooopack(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_snd_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x02000000U); + ClearHasBit(_impl_._has_bits_[3], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) @@ -7630,7 +7735,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_wnd(::uint32_t value) { _internal_set_tcp_info_snd_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x02000000U); + SetHasBit(_impl_._has_bits_[3], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_wnd() const { @@ -7646,7 +7751,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x04000000U); + ClearHasBit(_impl_._has_bits_[3], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) @@ -7654,7 +7759,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_wnd(::uint32_t value) { _internal_set_tcp_info_rcv_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x04000000U); + SetHasBit(_impl_._has_bits_[3], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_wnd() const { @@ -7670,7 +7775,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rehash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rehash_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x08000000U); + ClearHasBit(_impl_._has_bits_[3], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) @@ -7678,7 +7783,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { } inline void XtcpFlatRecord::set_tcp_info_rehash(::uint32_t value) { _internal_set_tcp_info_rehash(value); - SetHasBit(_impl_._has_bits_[3], 0x08000000U); + SetHasBit(_impl_._has_bits_[3], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rehash() const { @@ -7694,7 +7799,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rehash(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x10000000U); + ClearHasBit(_impl_._has_bits_[3], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) @@ -7702,7 +7807,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto(::uint32_t value) { _internal_set_tcp_info_total_rto(value); - SetHasBit(_impl_._has_bits_[3], 0x10000000U); + SetHasBit(_impl_._has_bits_[3], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto() const { @@ -7718,7 +7823,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto_recoveries() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_recoveries_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x20000000U); + ClearHasBit(_impl_._has_bits_[3], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) @@ -7726,7 +7831,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_recoveries(::uint32_t value) { _internal_set_tcp_info_total_rto_recoveries(value); - SetHasBit(_impl_._has_bits_[3], 0x20000000U); + SetHasBit(_impl_._has_bits_[3], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_recoveries() const { @@ -7742,7 +7847,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto_recoveries(::uint32 inline void XtcpFlatRecord::clear_tcp_info_total_rto_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_time_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x40000000U); + ClearHasBit(_impl_._has_bits_[3], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) @@ -7750,7 +7855,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_time(::uint32_t value) { _internal_set_tcp_info_total_rto_time(value); - SetHasBit(_impl_._has_bits_[3], 0x40000000U); + SetHasBit(_impl_._has_bits_[3], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_time() const { @@ -7830,7 +7935,7 @@ inline void XtcpFlatRecord::set_allocated_congestion_algorithm_string(::std::str inline void XtcpFlatRecord::clear_congestion_algorithm_enum() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.congestion_algorithm_enum_ = 0; - ClearHasBit(_impl_._has_bits_[3], 0x80000000U); + ClearHasBit(_impl_._has_bits_[4], 0x00000001U); } inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::congestion_algorithm_enum() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) @@ -7838,7 +7943,7 @@ inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord } inline void XtcpFlatRecord::set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { _internal_set_congestion_algorithm_enum(value); - SetHasBit(_impl_._has_bits_[3], 0x80000000U); + SetHasBit(_impl_._has_bits_[4], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) } inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::_internal_congestion_algorithm_enum() const { @@ -7854,7 +7959,7 @@ inline void XtcpFlatRecord::_internal_set_congestion_algorithm_enum(::xtcp_flat_ inline void XtcpFlatRecord::clear_type_of_service() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.type_of_service_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000001U); + ClearHasBit(_impl_._has_bits_[4], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::type_of_service() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) @@ -7862,7 +7967,7 @@ inline ::uint32_t XtcpFlatRecord::type_of_service() const { } inline void XtcpFlatRecord::set_type_of_service(::uint32_t value) { _internal_set_type_of_service(value); - SetHasBit(_impl_._has_bits_[4], 0x00000001U); + SetHasBit(_impl_._has_bits_[4], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) } inline ::uint32_t XtcpFlatRecord::_internal_type_of_service() const { @@ -7878,7 +7983,7 @@ inline void XtcpFlatRecord::_internal_set_type_of_service(::uint32_t value) { inline void XtcpFlatRecord::clear_traffic_class() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.traffic_class_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000002U); + ClearHasBit(_impl_._has_bits_[4], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::traffic_class() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) @@ -7886,7 +7991,7 @@ inline ::uint32_t XtcpFlatRecord::traffic_class() const { } inline void XtcpFlatRecord::set_traffic_class(::uint32_t value) { _internal_set_traffic_class(value); - SetHasBit(_impl_._has_bits_[4], 0x00000002U); + SetHasBit(_impl_._has_bits_[4], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) } inline ::uint32_t XtcpFlatRecord::_internal_traffic_class() const { @@ -7902,7 +8007,7 @@ inline void XtcpFlatRecord::_internal_set_traffic_class(::uint32_t value) { inline void XtcpFlatRecord::clear_sk_mem_info_rmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_rmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000004U); + ClearHasBit(_impl_._has_bits_[4], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) @@ -7910,7 +8015,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_rmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_rmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000004U); + SetHasBit(_impl_._has_bits_[4], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rmem_alloc() const { @@ -7926,7 +8031,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_rmem_alloc(::uint32_t valu inline void XtcpFlatRecord::clear_sk_mem_info_rcv_buf() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_rcv_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000008U); + ClearHasBit(_impl_._has_bits_[4], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcv_buf() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) @@ -7934,7 +8039,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcv_buf() const { } inline void XtcpFlatRecord::set_sk_mem_info_rcv_buf(::uint32_t value) { _internal_set_sk_mem_info_rcv_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000008U); + SetHasBit(_impl_._has_bits_[4], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rcv_buf() const { @@ -7950,7 +8055,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_rcv_buf(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_wmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000010U); + ClearHasBit(_impl_._has_bits_[4], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) @@ -7958,7 +8063,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_wmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000010U); + SetHasBit(_impl_._has_bits_[4], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_alloc() const { @@ -7974,7 +8079,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_alloc(::uint32_t valu inline void XtcpFlatRecord::clear_sk_mem_info_snd_buf() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_snd_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000020U); + ClearHasBit(_impl_._has_bits_[4], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_snd_buf() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) @@ -7982,7 +8087,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_snd_buf() const { } inline void XtcpFlatRecord::set_sk_mem_info_snd_buf(::uint32_t value) { _internal_set_sk_mem_info_snd_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000020U); + SetHasBit(_impl_._has_bits_[4], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_snd_buf() const { @@ -7998,7 +8103,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_snd_buf(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_fwd_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_fwd_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000040U); + ClearHasBit(_impl_._has_bits_[4], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) @@ -8006,7 +8111,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_fwd_alloc(::uint32_t value) { _internal_set_sk_mem_info_fwd_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000040U); + SetHasBit(_impl_._has_bits_[4], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_fwd_alloc() const { @@ -8022,7 +8127,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_fwd_alloc(::uint32_t value inline void XtcpFlatRecord::clear_sk_mem_info_wmem_queued() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_queued_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000080U); + ClearHasBit(_impl_._has_bits_[4], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) @@ -8030,7 +8135,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_queued(::uint32_t value) { _internal_set_sk_mem_info_wmem_queued(value); - SetHasBit(_impl_._has_bits_[4], 0x00000080U); + SetHasBit(_impl_._has_bits_[4], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_queued() const { @@ -8046,7 +8151,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_queued(::uint32_t val inline void XtcpFlatRecord::clear_sk_mem_info_optmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_optmem_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000100U); + ClearHasBit(_impl_._has_bits_[4], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) @@ -8054,7 +8159,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { } inline void XtcpFlatRecord::set_sk_mem_info_optmem(::uint32_t value) { _internal_set_sk_mem_info_optmem(value); - SetHasBit(_impl_._has_bits_[4], 0x00000100U); + SetHasBit(_impl_._has_bits_[4], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_optmem() const { @@ -8070,7 +8175,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_optmem(::uint32_t value) { inline void XtcpFlatRecord::clear_sk_mem_info_backlog() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_backlog_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000200U); + ClearHasBit(_impl_._has_bits_[4], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) @@ -8078,7 +8183,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { } inline void XtcpFlatRecord::set_sk_mem_info_backlog(::uint32_t value) { _internal_set_sk_mem_info_backlog(value); - SetHasBit(_impl_._has_bits_[4], 0x00000200U); + SetHasBit(_impl_._has_bits_[4], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_backlog() const { @@ -8094,7 +8199,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_backlog(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_drops() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_drops_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000400U); + ClearHasBit(_impl_._has_bits_[4], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) @@ -8102,7 +8207,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { } inline void XtcpFlatRecord::set_sk_mem_info_drops(::uint32_t value) { _internal_set_sk_mem_info_drops(value); - SetHasBit(_impl_._has_bits_[4], 0x00000400U); + SetHasBit(_impl_._has_bits_[4], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_drops() const { @@ -8118,7 +8223,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_drops(::uint32_t value) { inline void XtcpFlatRecord::clear_shutdown_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.shutdown_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000800U); + ClearHasBit(_impl_._has_bits_[4], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::shutdown_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) @@ -8126,7 +8231,7 @@ inline ::uint32_t XtcpFlatRecord::shutdown_state() const { } inline void XtcpFlatRecord::set_shutdown_state(::uint32_t value) { _internal_set_shutdown_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00000800U); + SetHasBit(_impl_._has_bits_[4], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) } inline ::uint32_t XtcpFlatRecord::_internal_shutdown_state() const { @@ -8142,7 +8247,7 @@ inline void XtcpFlatRecord::_internal_set_shutdown_state(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00001000U); + ClearHasBit(_impl_._has_bits_[4], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) @@ -8150,7 +8255,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { } inline void XtcpFlatRecord::set_vegas_info_enabled(::uint32_t value) { _internal_set_vegas_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00001000U); + SetHasBit(_impl_._has_bits_[4], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_enabled() const { @@ -8166,7 +8271,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_enabled(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_rtt_cnt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_rtt_cnt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00002000U); + ClearHasBit(_impl_._has_bits_[4], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_rtt_cnt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) @@ -8174,7 +8279,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_rtt_cnt() const { } inline void XtcpFlatRecord::set_vegas_info_rtt_cnt(::uint32_t value) { _internal_set_vegas_info_rtt_cnt(value); - SetHasBit(_impl_._has_bits_[4], 0x00002000U); + SetHasBit(_impl_._has_bits_[4], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt_cnt() const { @@ -8190,7 +8295,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_rtt_cnt(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00004000U); + ClearHasBit(_impl_._has_bits_[4], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) @@ -8198,7 +8303,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { } inline void XtcpFlatRecord::set_vegas_info_rtt(::uint32_t value) { _internal_set_vegas_info_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00004000U); + SetHasBit(_impl_._has_bits_[4], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt() const { @@ -8214,7 +8319,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_vegas_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00008000U); + ClearHasBit(_impl_._has_bits_[4], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) @@ -8222,7 +8327,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_min_rtt() const { } inline void XtcpFlatRecord::set_vegas_info_min_rtt(::uint32_t value) { _internal_set_vegas_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00008000U); + SetHasBit(_impl_._has_bits_[4], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_min_rtt() const { @@ -8238,7 +8343,7 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00010000U); + ClearHasBit(_impl_._has_bits_[4], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) @@ -8246,7 +8351,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { } inline void XtcpFlatRecord::set_dctcp_info_enabled(::uint32_t value) { _internal_set_dctcp_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00010000U); + SetHasBit(_impl_._has_bits_[4], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_enabled() const { @@ -8262,7 +8367,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_enabled(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ce_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ce_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00020000U); + ClearHasBit(_impl_._has_bits_[4], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) @@ -8270,7 +8375,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { } inline void XtcpFlatRecord::set_dctcp_info_ce_state(::uint32_t value) { _internal_set_dctcp_info_ce_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00020000U); + SetHasBit(_impl_._has_bits_[4], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ce_state() const { @@ -8286,7 +8391,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ce_state(::uint32_t value) inline void XtcpFlatRecord::clear_dctcp_info_alpha() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_alpha_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00040000U); + ClearHasBit(_impl_._has_bits_[4], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) @@ -8294,7 +8399,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { } inline void XtcpFlatRecord::set_dctcp_info_alpha(::uint32_t value) { _internal_set_dctcp_info_alpha(value); - SetHasBit(_impl_._has_bits_[4], 0x00040000U); + SetHasBit(_impl_._has_bits_[4], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_alpha() const { @@ -8310,7 +8415,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_alpha(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_ecn() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_ecn_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00080000U); + ClearHasBit(_impl_._has_bits_[4], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) @@ -8318,7 +8423,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_ecn(::uint32_t value) { _internal_set_dctcp_info_ab_ecn(value); - SetHasBit(_impl_._has_bits_[4], 0x00080000U); + SetHasBit(_impl_._has_bits_[4], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_ecn() const { @@ -8334,7 +8439,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_ecn(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_tot() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_tot_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00100000U); + ClearHasBit(_impl_._has_bits_[4], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) @@ -8342,7 +8447,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_tot(::uint32_t value) { _internal_set_dctcp_info_ab_tot(value); - SetHasBit(_impl_._has_bits_[4], 0x00100000U); + SetHasBit(_impl_._has_bits_[4], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_tot() const { @@ -8358,7 +8463,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_tot(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_lo_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00200000U); + ClearHasBit(_impl_._has_bits_[4], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) @@ -8366,7 +8471,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { } inline void XtcpFlatRecord::set_bbr_info_bw_lo(::uint32_t value) { _internal_set_bbr_info_bw_lo(value); - SetHasBit(_impl_._has_bits_[4], 0x00200000U); + SetHasBit(_impl_._has_bits_[4], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_lo() const { @@ -8382,7 +8487,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_lo(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_hi_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00400000U); + ClearHasBit(_impl_._has_bits_[4], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) @@ -8390,7 +8495,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { } inline void XtcpFlatRecord::set_bbr_info_bw_hi(::uint32_t value) { _internal_set_bbr_info_bw_hi(value); - SetHasBit(_impl_._has_bits_[4], 0x00400000U); + SetHasBit(_impl_._has_bits_[4], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_hi() const { @@ -8406,7 +8511,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_hi(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00800000U); + ClearHasBit(_impl_._has_bits_[4], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) @@ -8414,7 +8519,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { } inline void XtcpFlatRecord::set_bbr_info_min_rtt(::uint32_t value) { _internal_set_bbr_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00800000U); + SetHasBit(_impl_._has_bits_[4], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_min_rtt() const { @@ -8430,7 +8535,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_pacing_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_pacing_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x01000000U); + ClearHasBit(_impl_._has_bits_[4], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) @@ -8438,7 +8543,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { } inline void XtcpFlatRecord::set_bbr_info_pacing_gain(::uint32_t value) { _internal_set_bbr_info_pacing_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x01000000U); + SetHasBit(_impl_._has_bits_[4], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_pacing_gain() const { @@ -8454,7 +8559,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_pacing_gain(::uint32_t value) inline void XtcpFlatRecord::clear_bbr_info_cwnd_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_cwnd_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x02000000U); + ClearHasBit(_impl_._has_bits_[4], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) @@ -8462,7 +8567,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { } inline void XtcpFlatRecord::set_bbr_info_cwnd_gain(::uint32_t value) { _internal_set_bbr_info_cwnd_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x02000000U); + SetHasBit(_impl_._has_bits_[4], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_cwnd_gain() const { @@ -8478,7 +8583,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_cwnd_gain(::uint32_t value) { inline void XtcpFlatRecord::clear_class_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.class_id_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x04000000U); + ClearHasBit(_impl_._has_bits_[4], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::class_id() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.class_id) @@ -8486,7 +8591,7 @@ inline ::uint32_t XtcpFlatRecord::class_id() const { } inline void XtcpFlatRecord::set_class_id(::uint32_t value) { _internal_set_class_id(value); - SetHasBit(_impl_._has_bits_[4], 0x04000000U); + SetHasBit(_impl_._has_bits_[4], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.class_id) } inline ::uint32_t XtcpFlatRecord::_internal_class_id() const { @@ -8502,7 +8607,7 @@ inline void XtcpFlatRecord::_internal_set_class_id(::uint32_t value) { inline void XtcpFlatRecord::clear_sock_opt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sock_opt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x08000000U); + ClearHasBit(_impl_._has_bits_[4], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::sock_opt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) @@ -8510,7 +8615,7 @@ inline ::uint32_t XtcpFlatRecord::sock_opt() const { } inline void XtcpFlatRecord::set_sock_opt(::uint32_t value) { _internal_set_sock_opt(value); - SetHasBit(_impl_._has_bits_[4], 0x08000000U); + SetHasBit(_impl_._has_bits_[4], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) } inline ::uint32_t XtcpFlatRecord::_internal_sock_opt() const { @@ -8770,6 +8875,12 @@ inline void PollFlatRecordsResponse::set_allocated_xtcp_flat_record(::xtcp_flat_ namespace google { namespace protobuf { +template <> +struct is_proto_enum<::xtcp_flat_record::v1::XtcpFlatRecord_Locality> : std::true_type {}; +template <> +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::xtcp_flat_record::v1::XtcpFlatRecord_Locality>() { + return ::xtcp_flat_record::v1::XtcpFlatRecord_Locality_descriptor(); +} template <> struct is_proto_enum<::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm> : std::true_type {}; template <> diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart index 9556f81..f2468dd 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart @@ -927,6 +927,8 @@ class XtcpConfig extends $pb.GeneratedMessage { $core.bool? enrichAsnEnable, $core.String? asnDbPath, $1.Duration? asnRefreshInterval, + $core.bool? enrichLocalityEnable, + $1.Duration? localityRefreshInterval, }) { final result = create(); if (nlTimeoutMilliseconds != null) @@ -1017,6 +1019,10 @@ class XtcpConfig extends $pb.GeneratedMessage { if (asnDbPath != null) result.asnDbPath = asnDbPath; if (asnRefreshInterval != null) result.asnRefreshInterval = asnRefreshInterval; + if (enrichLocalityEnable != null) + result.enrichLocalityEnable = enrichLocalityEnable; + if (localityRefreshInterval != null) + result.localityRefreshInterval = localityRefreshInterval; return result; } @@ -1138,6 +1144,9 @@ class XtcpConfig extends $pb.GeneratedMessage { ..aOS(240, _omitFieldNames ? '' : 'asnDbPath') ..aOM<$1.Duration>(241, _omitFieldNames ? '' : 'asnRefreshInterval', subBuilder: $1.Duration.create) + ..aOB(242, _omitFieldNames ? '' : 'enrichLocalityEnable') + ..aOM<$1.Duration>(243, _omitFieldNames ? '' : 'localityRefreshInterval', + subBuilder: $1.Duration.create) ..hasRequiredFields = false; @$core.Deprecated('See https://github.com/google/protobuf.dart/issues/998.') @@ -2016,6 +2025,36 @@ class XtcpConfig extends $pb.GeneratedMessage { void clearAsnRefreshInterval() => $_clearField(241); @$pb.TagNumber(241) $1.Duration ensureAsnRefreshInterval() => $_ensure(68); + + /// Classify the destination IP's locality (field 1019) — self / + /// connected-subnet / remote — from each monitored network namespace's local + /// addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs + /// BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: + /// a per-namespace discovery failure just leaves that namespace's sockets + /// unclassified. Default false. + @$pb.TagNumber(242) + $core.bool get enrichLocalityEnable => $_getBF(69); + @$pb.TagNumber(242) + set enrichLocalityEnable($core.bool value) => $_setBool(69, value); + @$pb.TagNumber(242) + $core.bool hasEnrichLocalityEnable() => $_has(69); + @$pb.TagNumber(242) + void clearEnrichLocalityEnable() => $_clearField(242); + + /// How often to re-discover local addresses/routes per namespace so runtime + /// changes (interfaces up/down, routes added) are picked up. Newly-appeared + /// namespaces are always snapshotted on the next reconcile regardless. 0 = + /// discover once per namespace, never refresh. + @$pb.TagNumber(243) + $1.Duration get localityRefreshInterval => $_getN(70); + @$pb.TagNumber(243) + set localityRefreshInterval($1.Duration value) => $_setField(243, value); + @$pb.TagNumber(243) + $core.bool hasLocalityRefreshInterval() => $_has(70); + @$pb.TagNumber(243) + void clearLocalityRefreshInterval() => $_clearField(243); + @$pb.TagNumber(243) + $1.Duration ensureLocalityRefreshInterval() => $_ensure(70); } class EnabledDeserializers extends $pb.GeneratedMessage { diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart index 90f3319..16b7028 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart @@ -710,6 +710,21 @@ const XtcpConfig$json = { '6': '.google.protobuf.Duration', '10': 'asnRefreshInterval' }, + { + '1': 'enrich_locality_enable', + '3': 242, + '4': 1, + '5': 8, + '10': 'enrichLocalityEnable' + }, + { + '1': 'locality_refresh_interval', + '3': 243, + '4': 1, + '5': 11, + '6': '.google.protobuf.Duration', + '10': 'localityRefreshInterval' + }, ], '7': {}, }; @@ -785,10 +800,12 @@ final $typed_data.Uint8List xtcpConfigDescriptor = $convert.base64Decode( 'cGxpbmtJbnRlcmZhY2VzEiQKDXBvcHVsYXRlX25zaWQY7gEgASgIUgxwb3B1bGF0ZU5zaWQSKw' 'oRZW5yaWNoX2Fzbl9lbmFibGUY7wEgASgIUg9lbnJpY2hBc25FbmFibGUSKQoLYXNuX2RiX3Bh' 'dGgY8AEgASgJQgi6SAVyAxj/AVIJYXNuRGJQYXRoEkwKFGFzbl9yZWZyZXNoX2ludGVydmFsGP' - 'EBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvblISYXNuUmVmcmVzaEludGVydmFsOnO6' - 'SHAabgoPWHRjcENvbmZpZy5wb2xsEjJQb2xsIHRpbWVvdXQgbXVzdCBiZSBsZXNzIHRoYW4gcG' - '9sbCBwb2xsX2ZyZXF1ZW5jeRondGhpcy5wb2xsX2ZyZXF1ZW5jeSA+IHRoaXMucG9sbF90aW1l' - 'b3V0'); + 'EBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvblISYXNuUmVmcmVzaEludGVydmFsEjUK' + 'FmVucmljaF9sb2NhbGl0eV9lbmFibGUY8gEgASgIUhRlbnJpY2hMb2NhbGl0eUVuYWJsZRJWCh' + 'lsb2NhbGl0eV9yZWZyZXNoX2ludGVydmFsGPMBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJh' + 'dGlvblIXbG9jYWxpdHlSZWZyZXNoSW50ZXJ2YWw6c7pIcBpuCg9YdGNwQ29uZmlnLnBvbGwSMl' + 'BvbGwgdGltZW91dCBtdXN0IGJlIGxlc3MgdGhhbiBwb2xsIHBvbGxfZnJlcXVlbmN5Gid0aGlz' + 'LnBvbGxfZnJlcXVlbmN5ID4gdGhpcy5wb2xsX3RpbWVvdXQ='); @$core.Deprecated('Use enabledDeserializersDescriptor instead') const EnabledDeserializers$json = { diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart index 1c6253f..5929dc8 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart @@ -140,6 +140,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? inetDiagMsgUid, $core.int? inetDiagMsgInode, $core.String? inetDiagMsgSocketDestNetworkOwner, + XtcpFlatRecord_Locality? inetDiagMsgSocketDestLocality, $core.int? memInfoRmem, $core.int? memInfoWmem, $core.int? memInfoFmem, @@ -326,6 +327,8 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (inetDiagMsgSocketDestNetworkOwner != null) result.inetDiagMsgSocketDestNetworkOwner = inetDiagMsgSocketDestNetworkOwner; + if (inetDiagMsgSocketDestLocality != null) + result.inetDiagMsgSocketDestLocality = inetDiagMsgSocketDestLocality; if (memInfoRmem != null) result.memInfoRmem = memInfoRmem; if (memInfoWmem != null) result.memInfoWmem = memInfoWmem; if (memInfoFmem != null) result.memInfoFmem = memInfoFmem; @@ -565,6 +568,9 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { ..aI(1017, _omitFieldNames ? '' : 'inetDiagMsgInode', fieldType: $pb.PbFieldType.OU3) ..aOS(1018, _omitFieldNames ? '' : 'inetDiagMsgSocketDestNetworkOwner') + ..aE( + 1019, _omitFieldNames ? '' : 'inetDiagMsgSocketDestLocality', + enumValues: XtcpFlatRecord_Locality.values) ..aI(1101, _omitFieldNames ? '' : 'memInfoRmem', fieldType: $pb.PbFieldType.OU3) ..aI(1102, _omitFieldNames ? '' : 'memInfoWmem', @@ -1392,6 +1398,16 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { @$pb.TagNumber(1018) void clearInetDiagMsgSocketDestNetworkOwner() => $_clearField(1018); + @$pb.TagNumber(1019) + XtcpFlatRecord_Locality get inetDiagMsgSocketDestLocality => $_getN(61); + @$pb.TagNumber(1019) + set inetDiagMsgSocketDestLocality(XtcpFlatRecord_Locality value) => + $_setField(1019, value); + @$pb.TagNumber(1019) + $core.bool hasInetDiagMsgSocketDestLocality() => $_has(61); + @$pb.TagNumber(1019) + void clearInetDiagMsgSocketDestLocality() => $_clearField(1019); + /// DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by /// default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), /// so these ship as 0 on current records. The same values live in sk_mem_info: @@ -1403,595 +1419,595 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// (Not marked `[deprecated = true]` so the still-supported opt-in decode path /// and tests don't trip staticcheck SA1019.) @$pb.TagNumber(1101) - $core.int get memInfoRmem => $_getIZ(61); + $core.int get memInfoRmem => $_getIZ(62); @$pb.TagNumber(1101) - set memInfoRmem($core.int value) => $_setUnsignedInt32(61, value); + set memInfoRmem($core.int value) => $_setUnsignedInt32(62, value); @$pb.TagNumber(1101) - $core.bool hasMemInfoRmem() => $_has(61); + $core.bool hasMemInfoRmem() => $_has(62); @$pb.TagNumber(1101) void clearMemInfoRmem() => $_clearField(1101); @$pb.TagNumber(1102) - $core.int get memInfoWmem => $_getIZ(62); + $core.int get memInfoWmem => $_getIZ(63); @$pb.TagNumber(1102) - set memInfoWmem($core.int value) => $_setUnsignedInt32(62, value); + set memInfoWmem($core.int value) => $_setUnsignedInt32(63, value); @$pb.TagNumber(1102) - $core.bool hasMemInfoWmem() => $_has(62); + $core.bool hasMemInfoWmem() => $_has(63); @$pb.TagNumber(1102) void clearMemInfoWmem() => $_clearField(1102); @$pb.TagNumber(1103) - $core.int get memInfoFmem => $_getIZ(63); + $core.int get memInfoFmem => $_getIZ(64); @$pb.TagNumber(1103) - set memInfoFmem($core.int value) => $_setUnsignedInt32(63, value); + set memInfoFmem($core.int value) => $_setUnsignedInt32(64, value); @$pb.TagNumber(1103) - $core.bool hasMemInfoFmem() => $_has(63); + $core.bool hasMemInfoFmem() => $_has(64); @$pb.TagNumber(1103) void clearMemInfoFmem() => $_clearField(1103); @$pb.TagNumber(1104) - $core.int get memInfoTmem => $_getIZ(64); + $core.int get memInfoTmem => $_getIZ(65); @$pb.TagNumber(1104) - set memInfoTmem($core.int value) => $_setUnsignedInt32(64, value); + set memInfoTmem($core.int value) => $_setUnsignedInt32(65, value); @$pb.TagNumber(1104) - $core.bool hasMemInfoTmem() => $_has(64); + $core.bool hasMemInfoTmem() => $_has(65); @$pb.TagNumber(1104) void clearMemInfoTmem() => $_clearField(1104); @$pb.TagNumber(1201) - $core.int get tcpInfoState => $_getIZ(65); + $core.int get tcpInfoState => $_getIZ(66); @$pb.TagNumber(1201) - set tcpInfoState($core.int value) => $_setUnsignedInt32(65, value); + set tcpInfoState($core.int value) => $_setUnsignedInt32(66, value); @$pb.TagNumber(1201) - $core.bool hasTcpInfoState() => $_has(65); + $core.bool hasTcpInfoState() => $_has(66); @$pb.TagNumber(1201) void clearTcpInfoState() => $_clearField(1201); @$pb.TagNumber(1202) - $core.int get tcpInfoCaState => $_getIZ(66); + $core.int get tcpInfoCaState => $_getIZ(67); @$pb.TagNumber(1202) - set tcpInfoCaState($core.int value) => $_setUnsignedInt32(66, value); + set tcpInfoCaState($core.int value) => $_setUnsignedInt32(67, value); @$pb.TagNumber(1202) - $core.bool hasTcpInfoCaState() => $_has(66); + $core.bool hasTcpInfoCaState() => $_has(67); @$pb.TagNumber(1202) void clearTcpInfoCaState() => $_clearField(1202); @$pb.TagNumber(1203) - $core.int get tcpInfoRetransmits => $_getIZ(67); + $core.int get tcpInfoRetransmits => $_getIZ(68); @$pb.TagNumber(1203) - set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(67, value); + set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(68, value); @$pb.TagNumber(1203) - $core.bool hasTcpInfoRetransmits() => $_has(67); + $core.bool hasTcpInfoRetransmits() => $_has(68); @$pb.TagNumber(1203) void clearTcpInfoRetransmits() => $_clearField(1203); @$pb.TagNumber(1204) - $core.int get tcpInfoProbes => $_getIZ(68); + $core.int get tcpInfoProbes => $_getIZ(69); @$pb.TagNumber(1204) - set tcpInfoProbes($core.int value) => $_setUnsignedInt32(68, value); + set tcpInfoProbes($core.int value) => $_setUnsignedInt32(69, value); @$pb.TagNumber(1204) - $core.bool hasTcpInfoProbes() => $_has(68); + $core.bool hasTcpInfoProbes() => $_has(69); @$pb.TagNumber(1204) void clearTcpInfoProbes() => $_clearField(1204); @$pb.TagNumber(1205) - $core.int get tcpInfoBackoff => $_getIZ(69); + $core.int get tcpInfoBackoff => $_getIZ(70); @$pb.TagNumber(1205) - set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(69, value); + set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(70, value); @$pb.TagNumber(1205) - $core.bool hasTcpInfoBackoff() => $_has(69); + $core.bool hasTcpInfoBackoff() => $_has(70); @$pb.TagNumber(1205) void clearTcpInfoBackoff() => $_clearField(1205); @$pb.TagNumber(1206) - $core.int get tcpInfoOptions => $_getIZ(70); + $core.int get tcpInfoOptions => $_getIZ(71); @$pb.TagNumber(1206) - set tcpInfoOptions($core.int value) => $_setUnsignedInt32(70, value); + set tcpInfoOptions($core.int value) => $_setUnsignedInt32(71, value); @$pb.TagNumber(1206) - $core.bool hasTcpInfoOptions() => $_has(70); + $core.bool hasTcpInfoOptions() => $_has(71); @$pb.TagNumber(1206) void clearTcpInfoOptions() => $_clearField(1206); /// __u8 _snd_wscale : 4, _rcv_wscale : 4; /// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; @$pb.TagNumber(1207) - $core.int get tcpInfoSendScale => $_getIZ(71); + $core.int get tcpInfoSendScale => $_getIZ(72); @$pb.TagNumber(1207) - set tcpInfoSendScale($core.int value) => $_setUnsignedInt32(71, value); + set tcpInfoSendScale($core.int value) => $_setUnsignedInt32(72, value); @$pb.TagNumber(1207) - $core.bool hasTcpInfoSendScale() => $_has(71); + $core.bool hasTcpInfoSendScale() => $_has(72); @$pb.TagNumber(1207) void clearTcpInfoSendScale() => $_clearField(1207); @$pb.TagNumber(1208) - $core.int get tcpInfoRcvScale => $_getIZ(72); + $core.int get tcpInfoRcvScale => $_getIZ(73); @$pb.TagNumber(1208) - set tcpInfoRcvScale($core.int value) => $_setUnsignedInt32(72, value); + set tcpInfoRcvScale($core.int value) => $_setUnsignedInt32(73, value); @$pb.TagNumber(1208) - $core.bool hasTcpInfoRcvScale() => $_has(72); + $core.bool hasTcpInfoRcvScale() => $_has(73); @$pb.TagNumber(1208) void clearTcpInfoRcvScale() => $_clearField(1208); @$pb.TagNumber(1209) - $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(73); + $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(74); @$pb.TagNumber(1209) set tcpInfoDeliveryRateAppLimited($core.int value) => - $_setUnsignedInt32(73, value); + $_setUnsignedInt32(74, value); @$pb.TagNumber(1209) - $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(73); + $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(74); @$pb.TagNumber(1209) void clearTcpInfoDeliveryRateAppLimited() => $_clearField(1209); @$pb.TagNumber(1210) - $core.int get tcpInfoFastOpenClientFailed => $_getIZ(74); + $core.int get tcpInfoFastOpenClientFailed => $_getIZ(75); @$pb.TagNumber(1210) set tcpInfoFastOpenClientFailed($core.int value) => - $_setUnsignedInt32(74, value); + $_setUnsignedInt32(75, value); @$pb.TagNumber(1210) - $core.bool hasTcpInfoFastOpenClientFailed() => $_has(74); + $core.bool hasTcpInfoFastOpenClientFailed() => $_has(75); @$pb.TagNumber(1210) void clearTcpInfoFastOpenClientFailed() => $_clearField(1210); @$pb.TagNumber(1215) - $core.int get tcpInfoRto => $_getIZ(75); + $core.int get tcpInfoRto => $_getIZ(76); @$pb.TagNumber(1215) - set tcpInfoRto($core.int value) => $_setUnsignedInt32(75, value); + set tcpInfoRto($core.int value) => $_setUnsignedInt32(76, value); @$pb.TagNumber(1215) - $core.bool hasTcpInfoRto() => $_has(75); + $core.bool hasTcpInfoRto() => $_has(76); @$pb.TagNumber(1215) void clearTcpInfoRto() => $_clearField(1215); @$pb.TagNumber(1216) - $core.int get tcpInfoAto => $_getIZ(76); + $core.int get tcpInfoAto => $_getIZ(77); @$pb.TagNumber(1216) - set tcpInfoAto($core.int value) => $_setUnsignedInt32(76, value); + set tcpInfoAto($core.int value) => $_setUnsignedInt32(77, value); @$pb.TagNumber(1216) - $core.bool hasTcpInfoAto() => $_has(76); + $core.bool hasTcpInfoAto() => $_has(77); @$pb.TagNumber(1216) void clearTcpInfoAto() => $_clearField(1216); @$pb.TagNumber(1217) - $core.int get tcpInfoSndMss => $_getIZ(77); + $core.int get tcpInfoSndMss => $_getIZ(78); @$pb.TagNumber(1217) - set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(77, value); + set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(78, value); @$pb.TagNumber(1217) - $core.bool hasTcpInfoSndMss() => $_has(77); + $core.bool hasTcpInfoSndMss() => $_has(78); @$pb.TagNumber(1217) void clearTcpInfoSndMss() => $_clearField(1217); @$pb.TagNumber(1218) - $core.int get tcpInfoRcvMss => $_getIZ(78); + $core.int get tcpInfoRcvMss => $_getIZ(79); @$pb.TagNumber(1218) - set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(78, value); + set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(79, value); @$pb.TagNumber(1218) - $core.bool hasTcpInfoRcvMss() => $_has(78); + $core.bool hasTcpInfoRcvMss() => $_has(79); @$pb.TagNumber(1218) void clearTcpInfoRcvMss() => $_clearField(1218); @$pb.TagNumber(1219) - $core.int get tcpInfoUnacked => $_getIZ(79); + $core.int get tcpInfoUnacked => $_getIZ(80); @$pb.TagNumber(1219) - set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(79, value); + set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(80, value); @$pb.TagNumber(1219) - $core.bool hasTcpInfoUnacked() => $_has(79); + $core.bool hasTcpInfoUnacked() => $_has(80); @$pb.TagNumber(1219) void clearTcpInfoUnacked() => $_clearField(1219); @$pb.TagNumber(1220) - $core.int get tcpInfoSacked => $_getIZ(80); + $core.int get tcpInfoSacked => $_getIZ(81); @$pb.TagNumber(1220) - set tcpInfoSacked($core.int value) => $_setUnsignedInt32(80, value); + set tcpInfoSacked($core.int value) => $_setUnsignedInt32(81, value); @$pb.TagNumber(1220) - $core.bool hasTcpInfoSacked() => $_has(80); + $core.bool hasTcpInfoSacked() => $_has(81); @$pb.TagNumber(1220) void clearTcpInfoSacked() => $_clearField(1220); @$pb.TagNumber(1221) - $core.int get tcpInfoLost => $_getIZ(81); + $core.int get tcpInfoLost => $_getIZ(82); @$pb.TagNumber(1221) - set tcpInfoLost($core.int value) => $_setUnsignedInt32(81, value); + set tcpInfoLost($core.int value) => $_setUnsignedInt32(82, value); @$pb.TagNumber(1221) - $core.bool hasTcpInfoLost() => $_has(81); + $core.bool hasTcpInfoLost() => $_has(82); @$pb.TagNumber(1221) void clearTcpInfoLost() => $_clearField(1221); @$pb.TagNumber(1222) - $core.int get tcpInfoRetrans => $_getIZ(82); + $core.int get tcpInfoRetrans => $_getIZ(83); @$pb.TagNumber(1222) - set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(82, value); + set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(83, value); @$pb.TagNumber(1222) - $core.bool hasTcpInfoRetrans() => $_has(82); + $core.bool hasTcpInfoRetrans() => $_has(83); @$pb.TagNumber(1222) void clearTcpInfoRetrans() => $_clearField(1222); @$pb.TagNumber(1223) - $core.int get tcpInfoFackets => $_getIZ(83); + $core.int get tcpInfoFackets => $_getIZ(84); @$pb.TagNumber(1223) - set tcpInfoFackets($core.int value) => $_setUnsignedInt32(83, value); + set tcpInfoFackets($core.int value) => $_setUnsignedInt32(84, value); @$pb.TagNumber(1223) - $core.bool hasTcpInfoFackets() => $_has(83); + $core.bool hasTcpInfoFackets() => $_has(84); @$pb.TagNumber(1223) void clearTcpInfoFackets() => $_clearField(1223); /// Times @$pb.TagNumber(1224) - $core.int get tcpInfoLastDataSent => $_getIZ(84); + $core.int get tcpInfoLastDataSent => $_getIZ(85); @$pb.TagNumber(1224) - set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(84, value); + set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(85, value); @$pb.TagNumber(1224) - $core.bool hasTcpInfoLastDataSent() => $_has(84); + $core.bool hasTcpInfoLastDataSent() => $_has(85); @$pb.TagNumber(1224) void clearTcpInfoLastDataSent() => $_clearField(1224); @$pb.TagNumber(1225) - $core.int get tcpInfoLastAckSent => $_getIZ(85); + $core.int get tcpInfoLastAckSent => $_getIZ(86); @$pb.TagNumber(1225) - set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(85, value); + set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(86, value); @$pb.TagNumber(1225) - $core.bool hasTcpInfoLastAckSent() => $_has(85); + $core.bool hasTcpInfoLastAckSent() => $_has(86); @$pb.TagNumber(1225) void clearTcpInfoLastAckSent() => $_clearField(1225); @$pb.TagNumber(1226) - $core.int get tcpInfoLastDataRecv => $_getIZ(86); + $core.int get tcpInfoLastDataRecv => $_getIZ(87); @$pb.TagNumber(1226) - set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(86, value); + set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(87, value); @$pb.TagNumber(1226) - $core.bool hasTcpInfoLastDataRecv() => $_has(86); + $core.bool hasTcpInfoLastDataRecv() => $_has(87); @$pb.TagNumber(1226) void clearTcpInfoLastDataRecv() => $_clearField(1226); @$pb.TagNumber(1227) - $core.int get tcpInfoLastAckRecv => $_getIZ(87); + $core.int get tcpInfoLastAckRecv => $_getIZ(88); @$pb.TagNumber(1227) - set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(87, value); + set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(88, value); @$pb.TagNumber(1227) - $core.bool hasTcpInfoLastAckRecv() => $_has(87); + $core.bool hasTcpInfoLastAckRecv() => $_has(88); @$pb.TagNumber(1227) void clearTcpInfoLastAckRecv() => $_clearField(1227); /// Metrics @$pb.TagNumber(1228) - $core.int get tcpInfoPmtu => $_getIZ(88); + $core.int get tcpInfoPmtu => $_getIZ(89); @$pb.TagNumber(1228) - set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(88, value); + set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(89, value); @$pb.TagNumber(1228) - $core.bool hasTcpInfoPmtu() => $_has(88); + $core.bool hasTcpInfoPmtu() => $_has(89); @$pb.TagNumber(1228) void clearTcpInfoPmtu() => $_clearField(1228); @$pb.TagNumber(1229) - $core.int get tcpInfoRcvSsthresh => $_getIZ(89); + $core.int get tcpInfoRcvSsthresh => $_getIZ(90); @$pb.TagNumber(1229) - set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(89, value); + set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(90, value); @$pb.TagNumber(1229) - $core.bool hasTcpInfoRcvSsthresh() => $_has(89); + $core.bool hasTcpInfoRcvSsthresh() => $_has(90); @$pb.TagNumber(1229) void clearTcpInfoRcvSsthresh() => $_clearField(1229); @$pb.TagNumber(1230) - $core.int get tcpInfoRtt => $_getIZ(90); + $core.int get tcpInfoRtt => $_getIZ(91); @$pb.TagNumber(1230) - set tcpInfoRtt($core.int value) => $_setUnsignedInt32(90, value); + set tcpInfoRtt($core.int value) => $_setUnsignedInt32(91, value); @$pb.TagNumber(1230) - $core.bool hasTcpInfoRtt() => $_has(90); + $core.bool hasTcpInfoRtt() => $_has(91); @$pb.TagNumber(1230) void clearTcpInfoRtt() => $_clearField(1230); @$pb.TagNumber(1231) - $core.int get tcpInfoRttVar => $_getIZ(91); + $core.int get tcpInfoRttVar => $_getIZ(92); @$pb.TagNumber(1231) - set tcpInfoRttVar($core.int value) => $_setUnsignedInt32(91, value); + set tcpInfoRttVar($core.int value) => $_setUnsignedInt32(92, value); @$pb.TagNumber(1231) - $core.bool hasTcpInfoRttVar() => $_has(91); + $core.bool hasTcpInfoRttVar() => $_has(92); @$pb.TagNumber(1231) void clearTcpInfoRttVar() => $_clearField(1231); @$pb.TagNumber(1232) - $core.int get tcpInfoSndSsthresh => $_getIZ(92); + $core.int get tcpInfoSndSsthresh => $_getIZ(93); @$pb.TagNumber(1232) - set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(92, value); + set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(93, value); @$pb.TagNumber(1232) - $core.bool hasTcpInfoSndSsthresh() => $_has(92); + $core.bool hasTcpInfoSndSsthresh() => $_has(93); @$pb.TagNumber(1232) void clearTcpInfoSndSsthresh() => $_clearField(1232); @$pb.TagNumber(1233) - $core.int get tcpInfoSndCwnd => $_getIZ(93); + $core.int get tcpInfoSndCwnd => $_getIZ(94); @$pb.TagNumber(1233) - set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(93, value); + set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(94, value); @$pb.TagNumber(1233) - $core.bool hasTcpInfoSndCwnd() => $_has(93); + $core.bool hasTcpInfoSndCwnd() => $_has(94); @$pb.TagNumber(1233) void clearTcpInfoSndCwnd() => $_clearField(1233); @$pb.TagNumber(1234) - $core.int get tcpInfoAdvMss => $_getIZ(94); + $core.int get tcpInfoAdvMss => $_getIZ(95); @$pb.TagNumber(1234) - set tcpInfoAdvMss($core.int value) => $_setUnsignedInt32(94, value); + set tcpInfoAdvMss($core.int value) => $_setUnsignedInt32(95, value); @$pb.TagNumber(1234) - $core.bool hasTcpInfoAdvMss() => $_has(94); + $core.bool hasTcpInfoAdvMss() => $_has(95); @$pb.TagNumber(1234) void clearTcpInfoAdvMss() => $_clearField(1234); @$pb.TagNumber(1235) - $core.int get tcpInfoReordering => $_getIZ(95); + $core.int get tcpInfoReordering => $_getIZ(96); @$pb.TagNumber(1235) - set tcpInfoReordering($core.int value) => $_setUnsignedInt32(95, value); + set tcpInfoReordering($core.int value) => $_setUnsignedInt32(96, value); @$pb.TagNumber(1235) - $core.bool hasTcpInfoReordering() => $_has(95); + $core.bool hasTcpInfoReordering() => $_has(96); @$pb.TagNumber(1235) void clearTcpInfoReordering() => $_clearField(1235); @$pb.TagNumber(1236) - $core.int get tcpInfoRcvRtt => $_getIZ(96); + $core.int get tcpInfoRcvRtt => $_getIZ(97); @$pb.TagNumber(1236) - set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(96, value); + set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(97, value); @$pb.TagNumber(1236) - $core.bool hasTcpInfoRcvRtt() => $_has(96); + $core.bool hasTcpInfoRcvRtt() => $_has(97); @$pb.TagNumber(1236) void clearTcpInfoRcvRtt() => $_clearField(1236); @$pb.TagNumber(1237) - $core.int get tcpInfoRcvSpace => $_getIZ(97); + $core.int get tcpInfoRcvSpace => $_getIZ(98); @$pb.TagNumber(1237) - set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(97, value); + set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(98, value); @$pb.TagNumber(1237) - $core.bool hasTcpInfoRcvSpace() => $_has(97); + $core.bool hasTcpInfoRcvSpace() => $_has(98); @$pb.TagNumber(1237) void clearTcpInfoRcvSpace() => $_clearField(1237); @$pb.TagNumber(1238) - $core.int get tcpInfoTotalRetrans => $_getIZ(98); + $core.int get tcpInfoTotalRetrans => $_getIZ(99); @$pb.TagNumber(1238) - set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(98, value); + set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(99, value); @$pb.TagNumber(1238) - $core.bool hasTcpInfoTotalRetrans() => $_has(98); + $core.bool hasTcpInfoTotalRetrans() => $_has(99); @$pb.TagNumber(1238) void clearTcpInfoTotalRetrans() => $_clearField(1238); @$pb.TagNumber(1239) - $fixnum.Int64 get tcpInfoPacingRate => $_getI64(99); + $fixnum.Int64 get tcpInfoPacingRate => $_getI64(100); @$pb.TagNumber(1239) - set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(99, value); + set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(100, value); @$pb.TagNumber(1239) - $core.bool hasTcpInfoPacingRate() => $_has(99); + $core.bool hasTcpInfoPacingRate() => $_has(100); @$pb.TagNumber(1239) void clearTcpInfoPacingRate() => $_clearField(1239); @$pb.TagNumber(1240) - $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(100); + $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(101); @$pb.TagNumber(1240) - set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(100, value); + set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(101, value); @$pb.TagNumber(1240) - $core.bool hasTcpInfoMaxPacingRate() => $_has(100); + $core.bool hasTcpInfoMaxPacingRate() => $_has(101); @$pb.TagNumber(1240) void clearTcpInfoMaxPacingRate() => $_clearField(1240); @$pb.TagNumber(1241) - $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(101); + $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(102); @$pb.TagNumber(1241) - set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(101, value); + set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(102, value); @$pb.TagNumber(1241) - $core.bool hasTcpInfoBytesAcked() => $_has(101); + $core.bool hasTcpInfoBytesAcked() => $_has(102); @$pb.TagNumber(1241) void clearTcpInfoBytesAcked() => $_clearField(1241); @$pb.TagNumber(1242) - $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(102); + $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(103); @$pb.TagNumber(1242) - set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(102, value); + set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(103, value); @$pb.TagNumber(1242) - $core.bool hasTcpInfoBytesReceived() => $_has(102); + $core.bool hasTcpInfoBytesReceived() => $_has(103); @$pb.TagNumber(1242) void clearTcpInfoBytesReceived() => $_clearField(1242); @$pb.TagNumber(1243) - $core.int get tcpInfoSegsOut => $_getIZ(103); + $core.int get tcpInfoSegsOut => $_getIZ(104); @$pb.TagNumber(1243) - set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(103, value); + set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(104, value); @$pb.TagNumber(1243) - $core.bool hasTcpInfoSegsOut() => $_has(103); + $core.bool hasTcpInfoSegsOut() => $_has(104); @$pb.TagNumber(1243) void clearTcpInfoSegsOut() => $_clearField(1243); @$pb.TagNumber(1244) - $core.int get tcpInfoSegsIn => $_getIZ(104); + $core.int get tcpInfoSegsIn => $_getIZ(105); @$pb.TagNumber(1244) - set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(104, value); + set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(105, value); @$pb.TagNumber(1244) - $core.bool hasTcpInfoSegsIn() => $_has(104); + $core.bool hasTcpInfoSegsIn() => $_has(105); @$pb.TagNumber(1244) void clearTcpInfoSegsIn() => $_clearField(1244); @$pb.TagNumber(1245) - $core.int get tcpInfoNotSentBytes => $_getIZ(105); + $core.int get tcpInfoNotSentBytes => $_getIZ(106); @$pb.TagNumber(1245) - set tcpInfoNotSentBytes($core.int value) => $_setUnsignedInt32(105, value); + set tcpInfoNotSentBytes($core.int value) => $_setUnsignedInt32(106, value); @$pb.TagNumber(1245) - $core.bool hasTcpInfoNotSentBytes() => $_has(105); + $core.bool hasTcpInfoNotSentBytes() => $_has(106); @$pb.TagNumber(1245) void clearTcpInfoNotSentBytes() => $_clearField(1245); @$pb.TagNumber(1246) - $core.int get tcpInfoMinRtt => $_getIZ(106); + $core.int get tcpInfoMinRtt => $_getIZ(107); @$pb.TagNumber(1246) - set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(106, value); + set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(107, value); @$pb.TagNumber(1246) - $core.bool hasTcpInfoMinRtt() => $_has(106); + $core.bool hasTcpInfoMinRtt() => $_has(107); @$pb.TagNumber(1246) void clearTcpInfoMinRtt() => $_clearField(1246); @$pb.TagNumber(1247) - $core.int get tcpInfoDataSegsIn => $_getIZ(107); + $core.int get tcpInfoDataSegsIn => $_getIZ(108); @$pb.TagNumber(1247) - set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(107, value); + set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(108, value); @$pb.TagNumber(1247) - $core.bool hasTcpInfoDataSegsIn() => $_has(107); + $core.bool hasTcpInfoDataSegsIn() => $_has(108); @$pb.TagNumber(1247) void clearTcpInfoDataSegsIn() => $_clearField(1247); @$pb.TagNumber(1248) - $core.int get tcpInfoDataSegsOut => $_getIZ(108); + $core.int get tcpInfoDataSegsOut => $_getIZ(109); @$pb.TagNumber(1248) - set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(108, value); + set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(109, value); @$pb.TagNumber(1248) - $core.bool hasTcpInfoDataSegsOut() => $_has(108); + $core.bool hasTcpInfoDataSegsOut() => $_has(109); @$pb.TagNumber(1248) void clearTcpInfoDataSegsOut() => $_clearField(1248); @$pb.TagNumber(1249) - $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(109); + $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(110); @$pb.TagNumber(1249) - set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(109, value); + set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(110, value); @$pb.TagNumber(1249) - $core.bool hasTcpInfoDeliveryRate() => $_has(109); + $core.bool hasTcpInfoDeliveryRate() => $_has(110); @$pb.TagNumber(1249) void clearTcpInfoDeliveryRate() => $_clearField(1249); @$pb.TagNumber(1250) - $fixnum.Int64 get tcpInfoBusyTime => $_getI64(110); + $fixnum.Int64 get tcpInfoBusyTime => $_getI64(111); @$pb.TagNumber(1250) - set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(110, value); + set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(111, value); @$pb.TagNumber(1250) - $core.bool hasTcpInfoBusyTime() => $_has(110); + $core.bool hasTcpInfoBusyTime() => $_has(111); @$pb.TagNumber(1250) void clearTcpInfoBusyTime() => $_clearField(1250); @$pb.TagNumber(1251) - $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(111); + $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(112); @$pb.TagNumber(1251) - set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(111, value); + set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(112, value); @$pb.TagNumber(1251) - $core.bool hasTcpInfoRwndLimited() => $_has(111); + $core.bool hasTcpInfoRwndLimited() => $_has(112); @$pb.TagNumber(1251) void clearTcpInfoRwndLimited() => $_clearField(1251); @$pb.TagNumber(1252) - $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(112); + $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(113); @$pb.TagNumber(1252) - set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(112, value); + set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(113, value); @$pb.TagNumber(1252) - $core.bool hasTcpInfoSndbufLimited() => $_has(112); + $core.bool hasTcpInfoSndbufLimited() => $_has(113); @$pb.TagNumber(1252) void clearTcpInfoSndbufLimited() => $_clearField(1252); @$pb.TagNumber(1253) - $core.int get tcpInfoDelivered => $_getIZ(113); + $core.int get tcpInfoDelivered => $_getIZ(114); @$pb.TagNumber(1253) - set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(113, value); + set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(114, value); @$pb.TagNumber(1253) - $core.bool hasTcpInfoDelivered() => $_has(113); + $core.bool hasTcpInfoDelivered() => $_has(114); @$pb.TagNumber(1253) void clearTcpInfoDelivered() => $_clearField(1253); @$pb.TagNumber(1254) - $core.int get tcpInfoDeliveredCe => $_getIZ(114); + $core.int get tcpInfoDeliveredCe => $_getIZ(115); @$pb.TagNumber(1254) - set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(114, value); + set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(115, value); @$pb.TagNumber(1254) - $core.bool hasTcpInfoDeliveredCe() => $_has(114); + $core.bool hasTcpInfoDeliveredCe() => $_has(115); @$pb.TagNumber(1254) void clearTcpInfoDeliveredCe() => $_clearField(1254); /// https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB @$pb.TagNumber(1255) - $fixnum.Int64 get tcpInfoBytesSent => $_getI64(115); + $fixnum.Int64 get tcpInfoBytesSent => $_getI64(116); @$pb.TagNumber(1255) - set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(115, value); + set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(116, value); @$pb.TagNumber(1255) - $core.bool hasTcpInfoBytesSent() => $_has(115); + $core.bool hasTcpInfoBytesSent() => $_has(116); @$pb.TagNumber(1255) void clearTcpInfoBytesSent() => $_clearField(1255); @$pb.TagNumber(1256) - $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(116); + $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(117); @$pb.TagNumber(1256) - set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(116, value); + set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(117, value); @$pb.TagNumber(1256) - $core.bool hasTcpInfoBytesRetrans() => $_has(116); + $core.bool hasTcpInfoBytesRetrans() => $_has(117); @$pb.TagNumber(1256) void clearTcpInfoBytesRetrans() => $_clearField(1256); @$pb.TagNumber(1257) - $core.int get tcpInfoDsackDups => $_getIZ(117); + $core.int get tcpInfoDsackDups => $_getIZ(118); @$pb.TagNumber(1257) - set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(117, value); + set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(118, value); @$pb.TagNumber(1257) - $core.bool hasTcpInfoDsackDups() => $_has(117); + $core.bool hasTcpInfoDsackDups() => $_has(118); @$pb.TagNumber(1257) void clearTcpInfoDsackDups() => $_clearField(1257); @$pb.TagNumber(1258) - $core.int get tcpInfoReordSeen => $_getIZ(118); + $core.int get tcpInfoReordSeen => $_getIZ(119); @$pb.TagNumber(1258) - set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(118, value); + set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(119, value); @$pb.TagNumber(1258) - $core.bool hasTcpInfoReordSeen() => $_has(118); + $core.bool hasTcpInfoReordSeen() => $_has(119); @$pb.TagNumber(1258) void clearTcpInfoReordSeen() => $_clearField(1258); @$pb.TagNumber(1259) - $core.int get tcpInfoRcvOoopack => $_getIZ(119); + $core.int get tcpInfoRcvOoopack => $_getIZ(120); @$pb.TagNumber(1259) - set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(119, value); + set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(120, value); @$pb.TagNumber(1259) - $core.bool hasTcpInfoRcvOoopack() => $_has(119); + $core.bool hasTcpInfoRcvOoopack() => $_has(120); @$pb.TagNumber(1259) void clearTcpInfoRcvOoopack() => $_clearField(1259); @$pb.TagNumber(1260) - $core.int get tcpInfoSndWnd => $_getIZ(120); + $core.int get tcpInfoSndWnd => $_getIZ(121); @$pb.TagNumber(1260) - set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(120, value); + set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(121, value); @$pb.TagNumber(1260) - $core.bool hasTcpInfoSndWnd() => $_has(120); + $core.bool hasTcpInfoSndWnd() => $_has(121); @$pb.TagNumber(1260) void clearTcpInfoSndWnd() => $_clearField(1260); @$pb.TagNumber(1261) - $core.int get tcpInfoRcvWnd => $_getIZ(121); + $core.int get tcpInfoRcvWnd => $_getIZ(122); @$pb.TagNumber(1261) - set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(121, value); + set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(122, value); @$pb.TagNumber(1261) - $core.bool hasTcpInfoRcvWnd() => $_has(121); + $core.bool hasTcpInfoRcvWnd() => $_has(122); @$pb.TagNumber(1261) void clearTcpInfoRcvWnd() => $_clearField(1261); @$pb.TagNumber(1262) - $core.int get tcpInfoRehash => $_getIZ(122); + $core.int get tcpInfoRehash => $_getIZ(123); @$pb.TagNumber(1262) - set tcpInfoRehash($core.int value) => $_setUnsignedInt32(122, value); + set tcpInfoRehash($core.int value) => $_setUnsignedInt32(123, value); @$pb.TagNumber(1262) - $core.bool hasTcpInfoRehash() => $_has(122); + $core.bool hasTcpInfoRehash() => $_has(123); @$pb.TagNumber(1262) void clearTcpInfoRehash() => $_clearField(1262); @$pb.TagNumber(1263) - $core.int get tcpInfoTotalRto => $_getIZ(123); + $core.int get tcpInfoTotalRto => $_getIZ(124); @$pb.TagNumber(1263) - set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(123, value); + set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(124, value); @$pb.TagNumber(1263) - $core.bool hasTcpInfoTotalRto() => $_has(123); + $core.bool hasTcpInfoTotalRto() => $_has(124); @$pb.TagNumber(1263) void clearTcpInfoTotalRto() => $_clearField(1263); @$pb.TagNumber(1264) - $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(124); + $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(125); @$pb.TagNumber(1264) set tcpInfoTotalRtoRecoveries($core.int value) => - $_setUnsignedInt32(124, value); + $_setUnsignedInt32(125, value); @$pb.TagNumber(1264) - $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(124); + $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(125); @$pb.TagNumber(1264) void clearTcpInfoTotalRtoRecoveries() => $_clearField(1264); @$pb.TagNumber(1265) - $core.int get tcpInfoTotalRtoTime => $_getIZ(125); + $core.int get tcpInfoTotalRtoTime => $_getIZ(126); @$pb.TagNumber(1265) - set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(125, value); + set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(126, value); @$pb.TagNumber(1265) - $core.bool hasTcpInfoTotalRtoTime() => $_has(125); + $core.bool hasTcpInfoTotalRtoTime() => $_has(126); @$pb.TagNumber(1265) void clearTcpInfoTotalRtoTime() => $_clearField(1265); @@ -1999,282 +2015,282 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// just in case we need to quickly put a different algorithm in without updating the enum. /// Obviously it's optional, so it low cost. @$pb.TagNumber(1300) - $core.String get congestionAlgorithmString => $_getSZ(126); + $core.String get congestionAlgorithmString => $_getSZ(127); @$pb.TagNumber(1300) - set congestionAlgorithmString($core.String value) => $_setString(126, value); + set congestionAlgorithmString($core.String value) => $_setString(127, value); @$pb.TagNumber(1300) - $core.bool hasCongestionAlgorithmString() => $_has(126); + $core.bool hasCongestionAlgorithmString() => $_has(127); @$pb.TagNumber(1300) void clearCongestionAlgorithmString() => $_clearField(1300); @$pb.TagNumber(1301) - XtcpFlatRecord_CongestionAlgorithm get congestionAlgorithmEnum => $_getN(127); + XtcpFlatRecord_CongestionAlgorithm get congestionAlgorithmEnum => $_getN(128); @$pb.TagNumber(1301) set congestionAlgorithmEnum(XtcpFlatRecord_CongestionAlgorithm value) => $_setField(1301, value); @$pb.TagNumber(1301) - $core.bool hasCongestionAlgorithmEnum() => $_has(127); + $core.bool hasCongestionAlgorithmEnum() => $_has(128); @$pb.TagNumber(1301) void clearCongestionAlgorithmEnum() => $_clearField(1301); @$pb.TagNumber(1401) - $core.int get typeOfService => $_getIZ(128); + $core.int get typeOfService => $_getIZ(129); @$pb.TagNumber(1401) - set typeOfService($core.int value) => $_setUnsignedInt32(128, value); + set typeOfService($core.int value) => $_setUnsignedInt32(129, value); @$pb.TagNumber(1401) - $core.bool hasTypeOfService() => $_has(128); + $core.bool hasTypeOfService() => $_has(129); @$pb.TagNumber(1401) void clearTypeOfService() => $_clearField(1401); @$pb.TagNumber(1402) - $core.int get trafficClass => $_getIZ(129); + $core.int get trafficClass => $_getIZ(130); @$pb.TagNumber(1402) - set trafficClass($core.int value) => $_setUnsignedInt32(129, value); + set trafficClass($core.int value) => $_setUnsignedInt32(130, value); @$pb.TagNumber(1402) - $core.bool hasTrafficClass() => $_has(129); + $core.bool hasTrafficClass() => $_has(130); @$pb.TagNumber(1402) void clearTrafficClass() => $_clearField(1402); @$pb.TagNumber(1501) - $core.int get skMemInfoRmemAlloc => $_getIZ(130); + $core.int get skMemInfoRmemAlloc => $_getIZ(131); @$pb.TagNumber(1501) - set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(130, value); + set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(131, value); @$pb.TagNumber(1501) - $core.bool hasSkMemInfoRmemAlloc() => $_has(130); + $core.bool hasSkMemInfoRmemAlloc() => $_has(131); @$pb.TagNumber(1501) void clearSkMemInfoRmemAlloc() => $_clearField(1501); @$pb.TagNumber(1502) - $core.int get skMemInfoRcvBuf => $_getIZ(131); + $core.int get skMemInfoRcvBuf => $_getIZ(132); @$pb.TagNumber(1502) - set skMemInfoRcvBuf($core.int value) => $_setUnsignedInt32(131, value); + set skMemInfoRcvBuf($core.int value) => $_setUnsignedInt32(132, value); @$pb.TagNumber(1502) - $core.bool hasSkMemInfoRcvBuf() => $_has(131); + $core.bool hasSkMemInfoRcvBuf() => $_has(132); @$pb.TagNumber(1502) void clearSkMemInfoRcvBuf() => $_clearField(1502); @$pb.TagNumber(1503) - $core.int get skMemInfoWmemAlloc => $_getIZ(132); + $core.int get skMemInfoWmemAlloc => $_getIZ(133); @$pb.TagNumber(1503) - set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(132, value); + set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(133, value); @$pb.TagNumber(1503) - $core.bool hasSkMemInfoWmemAlloc() => $_has(132); + $core.bool hasSkMemInfoWmemAlloc() => $_has(133); @$pb.TagNumber(1503) void clearSkMemInfoWmemAlloc() => $_clearField(1503); @$pb.TagNumber(1504) - $core.int get skMemInfoSndBuf => $_getIZ(133); + $core.int get skMemInfoSndBuf => $_getIZ(134); @$pb.TagNumber(1504) - set skMemInfoSndBuf($core.int value) => $_setUnsignedInt32(133, value); + set skMemInfoSndBuf($core.int value) => $_setUnsignedInt32(134, value); @$pb.TagNumber(1504) - $core.bool hasSkMemInfoSndBuf() => $_has(133); + $core.bool hasSkMemInfoSndBuf() => $_has(134); @$pb.TagNumber(1504) void clearSkMemInfoSndBuf() => $_clearField(1504); @$pb.TagNumber(1505) - $core.int get skMemInfoFwdAlloc => $_getIZ(134); + $core.int get skMemInfoFwdAlloc => $_getIZ(135); @$pb.TagNumber(1505) - set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(134, value); + set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(135, value); @$pb.TagNumber(1505) - $core.bool hasSkMemInfoFwdAlloc() => $_has(134); + $core.bool hasSkMemInfoFwdAlloc() => $_has(135); @$pb.TagNumber(1505) void clearSkMemInfoFwdAlloc() => $_clearField(1505); @$pb.TagNumber(1506) - $core.int get skMemInfoWmemQueued => $_getIZ(135); + $core.int get skMemInfoWmemQueued => $_getIZ(136); @$pb.TagNumber(1506) - set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(135, value); + set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(136, value); @$pb.TagNumber(1506) - $core.bool hasSkMemInfoWmemQueued() => $_has(135); + $core.bool hasSkMemInfoWmemQueued() => $_has(136); @$pb.TagNumber(1506) void clearSkMemInfoWmemQueued() => $_clearField(1506); @$pb.TagNumber(1507) - $core.int get skMemInfoOptmem => $_getIZ(136); + $core.int get skMemInfoOptmem => $_getIZ(137); @$pb.TagNumber(1507) - set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(136, value); + set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(137, value); @$pb.TagNumber(1507) - $core.bool hasSkMemInfoOptmem() => $_has(136); + $core.bool hasSkMemInfoOptmem() => $_has(137); @$pb.TagNumber(1507) void clearSkMemInfoOptmem() => $_clearField(1507); @$pb.TagNumber(1508) - $core.int get skMemInfoBacklog => $_getIZ(137); + $core.int get skMemInfoBacklog => $_getIZ(138); @$pb.TagNumber(1508) - set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(137, value); + set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(138, value); @$pb.TagNumber(1508) - $core.bool hasSkMemInfoBacklog() => $_has(137); + $core.bool hasSkMemInfoBacklog() => $_has(138); @$pb.TagNumber(1508) void clearSkMemInfoBacklog() => $_clearField(1508); @$pb.TagNumber(1509) - $core.int get skMemInfoDrops => $_getIZ(138); + $core.int get skMemInfoDrops => $_getIZ(139); @$pb.TagNumber(1509) - set skMemInfoDrops($core.int value) => $_setUnsignedInt32(138, value); + set skMemInfoDrops($core.int value) => $_setUnsignedInt32(139, value); @$pb.TagNumber(1509) - $core.bool hasSkMemInfoDrops() => $_has(138); + $core.bool hasSkMemInfoDrops() => $_has(139); @$pb.TagNumber(1509) void clearSkMemInfoDrops() => $_clearField(1509); @$pb.TagNumber(1600) - $core.int get shutdownState => $_getIZ(139); + $core.int get shutdownState => $_getIZ(140); @$pb.TagNumber(1600) - set shutdownState($core.int value) => $_setUnsignedInt32(139, value); + set shutdownState($core.int value) => $_setUnsignedInt32(140, value); @$pb.TagNumber(1600) - $core.bool hasShutdownState() => $_has(139); + $core.bool hasShutdownState() => $_has(140); @$pb.TagNumber(1600) void clearShutdownState() => $_clearField(1600); @$pb.TagNumber(1701) - $core.int get vegasInfoEnabled => $_getIZ(140); + $core.int get vegasInfoEnabled => $_getIZ(141); @$pb.TagNumber(1701) - set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(140, value); + set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(141, value); @$pb.TagNumber(1701) - $core.bool hasVegasInfoEnabled() => $_has(140); + $core.bool hasVegasInfoEnabled() => $_has(141); @$pb.TagNumber(1701) void clearVegasInfoEnabled() => $_clearField(1701); @$pb.TagNumber(1702) - $core.int get vegasInfoRttCnt => $_getIZ(141); + $core.int get vegasInfoRttCnt => $_getIZ(142); @$pb.TagNumber(1702) - set vegasInfoRttCnt($core.int value) => $_setUnsignedInt32(141, value); + set vegasInfoRttCnt($core.int value) => $_setUnsignedInt32(142, value); @$pb.TagNumber(1702) - $core.bool hasVegasInfoRttCnt() => $_has(141); + $core.bool hasVegasInfoRttCnt() => $_has(142); @$pb.TagNumber(1702) void clearVegasInfoRttCnt() => $_clearField(1702); @$pb.TagNumber(1703) - $core.int get vegasInfoRtt => $_getIZ(142); + $core.int get vegasInfoRtt => $_getIZ(143); @$pb.TagNumber(1703) - set vegasInfoRtt($core.int value) => $_setUnsignedInt32(142, value); + set vegasInfoRtt($core.int value) => $_setUnsignedInt32(143, value); @$pb.TagNumber(1703) - $core.bool hasVegasInfoRtt() => $_has(142); + $core.bool hasVegasInfoRtt() => $_has(143); @$pb.TagNumber(1703) void clearVegasInfoRtt() => $_clearField(1703); @$pb.TagNumber(1704) - $core.int get vegasInfoMinRtt => $_getIZ(143); + $core.int get vegasInfoMinRtt => $_getIZ(144); @$pb.TagNumber(1704) - set vegasInfoMinRtt($core.int value) => $_setUnsignedInt32(143, value); + set vegasInfoMinRtt($core.int value) => $_setUnsignedInt32(144, value); @$pb.TagNumber(1704) - $core.bool hasVegasInfoMinRtt() => $_has(143); + $core.bool hasVegasInfoMinRtt() => $_has(144); @$pb.TagNumber(1704) void clearVegasInfoMinRtt() => $_clearField(1704); @$pb.TagNumber(1801) - $core.int get dctcpInfoEnabled => $_getIZ(144); + $core.int get dctcpInfoEnabled => $_getIZ(145); @$pb.TagNumber(1801) - set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(144, value); + set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(145, value); @$pb.TagNumber(1801) - $core.bool hasDctcpInfoEnabled() => $_has(144); + $core.bool hasDctcpInfoEnabled() => $_has(145); @$pb.TagNumber(1801) void clearDctcpInfoEnabled() => $_clearField(1801); @$pb.TagNumber(1802) - $core.int get dctcpInfoCeState => $_getIZ(145); + $core.int get dctcpInfoCeState => $_getIZ(146); @$pb.TagNumber(1802) - set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(145, value); + set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(146, value); @$pb.TagNumber(1802) - $core.bool hasDctcpInfoCeState() => $_has(145); + $core.bool hasDctcpInfoCeState() => $_has(146); @$pb.TagNumber(1802) void clearDctcpInfoCeState() => $_clearField(1802); @$pb.TagNumber(1803) - $core.int get dctcpInfoAlpha => $_getIZ(146); + $core.int get dctcpInfoAlpha => $_getIZ(147); @$pb.TagNumber(1803) - set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(146, value); + set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(147, value); @$pb.TagNumber(1803) - $core.bool hasDctcpInfoAlpha() => $_has(146); + $core.bool hasDctcpInfoAlpha() => $_has(147); @$pb.TagNumber(1803) void clearDctcpInfoAlpha() => $_clearField(1803); @$pb.TagNumber(1804) - $core.int get dctcpInfoAbEcn => $_getIZ(147); + $core.int get dctcpInfoAbEcn => $_getIZ(148); @$pb.TagNumber(1804) - set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(147, value); + set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(148, value); @$pb.TagNumber(1804) - $core.bool hasDctcpInfoAbEcn() => $_has(147); + $core.bool hasDctcpInfoAbEcn() => $_has(148); @$pb.TagNumber(1804) void clearDctcpInfoAbEcn() => $_clearField(1804); @$pb.TagNumber(1805) - $core.int get dctcpInfoAbTot => $_getIZ(148); + $core.int get dctcpInfoAbTot => $_getIZ(149); @$pb.TagNumber(1805) - set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(148, value); + set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(149, value); @$pb.TagNumber(1805) - $core.bool hasDctcpInfoAbTot() => $_has(148); + $core.bool hasDctcpInfoAbTot() => $_has(149); @$pb.TagNumber(1805) void clearDctcpInfoAbTot() => $_clearField(1805); @$pb.TagNumber(1901) - $core.int get bbrInfoBwLo => $_getIZ(149); + $core.int get bbrInfoBwLo => $_getIZ(150); @$pb.TagNumber(1901) - set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(149, value); + set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(150, value); @$pb.TagNumber(1901) - $core.bool hasBbrInfoBwLo() => $_has(149); + $core.bool hasBbrInfoBwLo() => $_has(150); @$pb.TagNumber(1901) void clearBbrInfoBwLo() => $_clearField(1901); @$pb.TagNumber(1902) - $core.int get bbrInfoBwHi => $_getIZ(150); + $core.int get bbrInfoBwHi => $_getIZ(151); @$pb.TagNumber(1902) - set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(150, value); + set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(151, value); @$pb.TagNumber(1902) - $core.bool hasBbrInfoBwHi() => $_has(150); + $core.bool hasBbrInfoBwHi() => $_has(151); @$pb.TagNumber(1902) void clearBbrInfoBwHi() => $_clearField(1902); @$pb.TagNumber(1903) - $core.int get bbrInfoMinRtt => $_getIZ(151); + $core.int get bbrInfoMinRtt => $_getIZ(152); @$pb.TagNumber(1903) - set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(151, value); + set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(152, value); @$pb.TagNumber(1903) - $core.bool hasBbrInfoMinRtt() => $_has(151); + $core.bool hasBbrInfoMinRtt() => $_has(152); @$pb.TagNumber(1903) void clearBbrInfoMinRtt() => $_clearField(1903); @$pb.TagNumber(1904) - $core.int get bbrInfoPacingGain => $_getIZ(152); + $core.int get bbrInfoPacingGain => $_getIZ(153); @$pb.TagNumber(1904) - set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(152, value); + set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(153, value); @$pb.TagNumber(1904) - $core.bool hasBbrInfoPacingGain() => $_has(152); + $core.bool hasBbrInfoPacingGain() => $_has(153); @$pb.TagNumber(1904) void clearBbrInfoPacingGain() => $_clearField(1904); @$pb.TagNumber(1905) - $core.int get bbrInfoCwndGain => $_getIZ(153); + $core.int get bbrInfoCwndGain => $_getIZ(154); @$pb.TagNumber(1905) - set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(153, value); + set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(154, value); @$pb.TagNumber(1905) - $core.bool hasBbrInfoCwndGain() => $_has(153); + $core.bool hasBbrInfoCwndGain() => $_has(154); @$pb.TagNumber(1905) void clearBbrInfoCwndGain() => $_clearField(1905); @$pb.TagNumber(2001) - $core.int get classId => $_getIZ(154); + $core.int get classId => $_getIZ(155); @$pb.TagNumber(2001) - set classId($core.int value) => $_setUnsignedInt32(154, value); + set classId($core.int value) => $_setUnsignedInt32(155, value); @$pb.TagNumber(2001) - $core.bool hasClassId() => $_has(154); + $core.bool hasClassId() => $_has(155); @$pb.TagNumber(2001) void clearClassId() => $_clearField(2001); @$pb.TagNumber(2002) - $core.int get sockOpt => $_getIZ(155); + $core.int get sockOpt => $_getIZ(156); @$pb.TagNumber(2002) - set sockOpt($core.int value) => $_setUnsignedInt32(155, value); + set sockOpt($core.int value) => $_setUnsignedInt32(156, value); @$pb.TagNumber(2002) - $core.bool hasSockOpt() => $_has(155); + $core.bool hasSockOpt() => $_has(156); @$pb.TagNumber(2002) void clearSockOpt() => $_clearField(2002); @$pb.TagNumber(2103) - $fixnum.Int64 get cGroup => $_getI64(156); + $fixnum.Int64 get cGroup => $_getI64(157); @$pb.TagNumber(2103) - set cGroup($fixnum.Int64 value) => $_setInt64(156, value); + set cGroup($fixnum.Int64 value) => $_setInt64(157, value); @$pb.TagNumber(2103) - $core.bool hasCGroup() => $_has(156); + $core.bool hasCGroup() => $_has(157); @$pb.TagNumber(2103) void clearCGroup() => $_clearField(2103); } diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart index 67ede6f..de264cb 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart @@ -14,6 +14,41 @@ import 'dart:core' as $core; import 'package:protobuf/protobuf.dart' as $pb; +/// Destination endpoint locality, classified from the socket's own network +/// namespace's local addresses + routing table (discovered via rtnetlink, +/// see pkg/localnet). Populated by the opt-in locality enricher BEFORE the +/// ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, +/// so dest_asn (1011) / dest_network_owner (1018) stay empty for them. +/// UNSPECIFIED when locality enrichment is disabled or the namespace has no +/// snapshot yet. +class XtcpFlatRecord_Locality extends $pb.ProtobufEnum { + static const XtcpFlatRecord_Locality LOCALITY_UNSPECIFIED = + XtcpFlatRecord_Locality._( + 0, _omitEnumNames ? '' : 'LOCALITY_UNSPECIFIED'); + static const XtcpFlatRecord_Locality LOCALITY_SELF = + XtcpFlatRecord_Locality._(1, _omitEnumNames ? '' : 'LOCALITY_SELF'); + static const XtcpFlatRecord_Locality LOCALITY_LOCAL_SUBNET = + XtcpFlatRecord_Locality._( + 2, _omitEnumNames ? '' : 'LOCALITY_LOCAL_SUBNET'); + static const XtcpFlatRecord_Locality LOCALITY_REMOTE = + XtcpFlatRecord_Locality._(3, _omitEnumNames ? '' : 'LOCALITY_REMOTE'); + + static const $core.List values = + [ + LOCALITY_UNSPECIFIED, + LOCALITY_SELF, + LOCALITY_LOCAL_SUBNET, + LOCALITY_REMOTE, + ]; + + static final $core.List _byValue = + $pb.ProtobufEnum.$_initByValueList(values, 3); + static XtcpFlatRecord_Locality? valueOf($core.int value) => + value < 0 || value >= _byValue.length ? null : _byValue[value]; + + const XtcpFlatRecord_Locality._(super.value, super.name); +} + class XtcpFlatRecord_CongestionAlgorithm extends $pb.ProtobufEnum { static const XtcpFlatRecord_CongestionAlgorithm CONGESTION_ALGORITHM_UNSPECIFIED = XtcpFlatRecord_CongestionAlgorithm._( diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart index 3554d0c..9d24bc7 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart @@ -358,6 +358,14 @@ const XtcpFlatRecord$json = { '5': 9, '10': 'inetDiagMsgSocketDestNetworkOwner' }, + { + '1': 'inet_diag_msg_socket_dest_locality', + '3': 1019, + '4': 1, + '5': 14, + '6': '.xtcp_flat_record.v1.XtcpFlatRecord.Locality', + '10': 'inetDiagMsgSocketDestLocality' + }, {'1': 'mem_info_rmem', '3': 1101, '4': 1, '5': 13, '10': 'memInfoRmem'}, {'1': 'mem_info_wmem', '3': 1102, '4': 1, '5': 13, '10': 'memInfoWmem'}, {'1': 'mem_info_fmem', '3': 1103, '4': 1, '5': 13, '10': 'memInfoFmem'}, @@ -900,7 +908,18 @@ const XtcpFlatRecord$json = { {'1': 'sock_opt', '3': 2002, '4': 1, '5': 13, '10': 'sockOpt'}, {'1': 'c_group', '3': 2103, '4': 1, '5': 4, '10': 'cGroup'}, ], - '4': [XtcpFlatRecord_CongestionAlgorithm$json], + '4': [XtcpFlatRecord_Locality$json, XtcpFlatRecord_CongestionAlgorithm$json], +}; + +@$core.Deprecated('Use xtcpFlatRecordDescriptor instead') +const XtcpFlatRecord_Locality$json = { + '1': 'Locality', + '2': [ + {'1': 'LOCALITY_UNSPECIFIED', '2': 0}, + {'1': 'LOCALITY_SELF', '2': 1}, + {'1': 'LOCALITY_LOCAL_SUBNET', '2': 2}, + {'1': 'LOCALITY_REMOTE', '2': 3}, + ], }; @$core.Deprecated('Use xtcpFlatRecordDescriptor instead') @@ -973,94 +992,98 @@ final $typed_data.Uint8List xtcpFlatRecordDescriptor = $convert.base64Decode( 'GPcHIAEoDVIRaW5ldERpYWdNc2dXcXVldWUSKgoRaW5ldF9kaWFnX21zZ191aWQY+AcgASgNUg' '5pbmV0RGlhZ01zZ1VpZBIuChNpbmV0X2RpYWdfbXNnX2lub2RlGPkHIAEoDVIQaW5ldERpYWdN' 'c2dJbm9kZRJTCidpbmV0X2RpYWdfbXNnX3NvY2tldF9kZXN0X25ldHdvcmtfb3duZXIY+gcgAS' - 'gJUiFpbmV0RGlhZ01zZ1NvY2tldERlc3ROZXR3b3JrT3duZXISIwoNbWVtX2luZm9fcm1lbRjN' - 'CCABKA1SC21lbUluZm9SbWVtEiMKDW1lbV9pbmZvX3dtZW0YzgggASgNUgttZW1JbmZvV21lbR' - 'IjCg1tZW1faW5mb19mbWVtGM8IIAEoDVILbWVtSW5mb0ZtZW0SIwoNbWVtX2luZm9fdG1lbRjQ' - 'CCABKA1SC21lbUluZm9UbWVtEiUKDnRjcF9pbmZvX3N0YXRlGLEJIAEoDVIMdGNwSW5mb1N0YX' - 'RlEioKEXRjcF9pbmZvX2NhX3N0YXRlGLIJIAEoDVIOdGNwSW5mb0NhU3RhdGUSMQoUdGNwX2lu' - 'Zm9fcmV0cmFuc21pdHMYswkgASgNUhJ0Y3BJbmZvUmV0cmFuc21pdHMSJwoPdGNwX2luZm9fcH' - 'JvYmVzGLQJIAEoDVINdGNwSW5mb1Byb2JlcxIpChB0Y3BfaW5mb19iYWNrb2ZmGLUJIAEoDVIO' - 'dGNwSW5mb0JhY2tvZmYSKQoQdGNwX2luZm9fb3B0aW9ucxi2CSABKA1SDnRjcEluZm9PcHRpb2' - '5zEi4KE3RjcF9pbmZvX3NlbmRfc2NhbGUYtwkgASgNUhB0Y3BJbmZvU2VuZFNjYWxlEiwKEnRj' - 'cF9pbmZvX3Jjdl9zY2FsZRi4CSABKA1SD3RjcEluZm9SY3ZTY2FsZRJKCiJ0Y3BfaW5mb19kZW' - 'xpdmVyeV9yYXRlX2FwcF9saW1pdGVkGLkJIAEoDVIddGNwSW5mb0RlbGl2ZXJ5UmF0ZUFwcExp' - 'bWl0ZWQSRgogdGNwX2luZm9fZmFzdF9vcGVuX2NsaWVudF9mYWlsZWQYugkgASgNUht0Y3BJbm' - 'ZvRmFzdE9wZW5DbGllbnRGYWlsZWQSIQoMdGNwX2luZm9fcnRvGL8JIAEoDVIKdGNwSW5mb1J0' - 'bxIhCgx0Y3BfaW5mb19hdG8YwAkgASgNUgp0Y3BJbmZvQXRvEigKEHRjcF9pbmZvX3NuZF9tc3' - 'MYwQkgASgNUg10Y3BJbmZvU25kTXNzEigKEHRjcF9pbmZvX3Jjdl9tc3MYwgkgASgNUg10Y3BJ' - 'bmZvUmN2TXNzEikKEHRjcF9pbmZvX3VuYWNrZWQYwwkgASgNUg50Y3BJbmZvVW5hY2tlZBInCg' - '90Y3BfaW5mb19zYWNrZWQYxAkgASgNUg10Y3BJbmZvU2Fja2VkEiMKDXRjcF9pbmZvX2xvc3QY' - 'xQkgASgNUgt0Y3BJbmZvTG9zdBIpChB0Y3BfaW5mb19yZXRyYW5zGMYJIAEoDVIOdGNwSW5mb1' - 'JldHJhbnMSKQoQdGNwX2luZm9fZmFja2V0cxjHCSABKA1SDnRjcEluZm9GYWNrZXRzEjUKF3Rj' - 'cF9pbmZvX2xhc3RfZGF0YV9zZW50GMgJIAEoDVITdGNwSW5mb0xhc3REYXRhU2VudBIzChZ0Y3' - 'BfaW5mb19sYXN0X2Fja19zZW50GMkJIAEoDVISdGNwSW5mb0xhc3RBY2tTZW50EjUKF3RjcF9p' - 'bmZvX2xhc3RfZGF0YV9yZWN2GMoJIAEoDVITdGNwSW5mb0xhc3REYXRhUmVjdhIzChZ0Y3BfaW' - '5mb19sYXN0X2Fja19yZWN2GMsJIAEoDVISdGNwSW5mb0xhc3RBY2tSZWN2EiMKDXRjcF9pbmZv' - 'X3BtdHUYzAkgASgNUgt0Y3BJbmZvUG10dRIyChV0Y3BfaW5mb19yY3Zfc3N0aHJlc2gYzQkgAS' - 'gNUhJ0Y3BJbmZvUmN2U3N0aHJlc2gSIQoMdGNwX2luZm9fcnR0GM4JIAEoDVIKdGNwSW5mb1J0' - 'dBIoChB0Y3BfaW5mb19ydHRfdmFyGM8JIAEoDVINdGNwSW5mb1J0dFZhchIyChV0Y3BfaW5mb1' - '9zbmRfc3N0aHJlc2gY0AkgASgNUhJ0Y3BJbmZvU25kU3N0aHJlc2gSKgoRdGNwX2luZm9fc25k' - 'X2N3bmQY0QkgASgNUg50Y3BJbmZvU25kQ3duZBIoChB0Y3BfaW5mb19hZHZfbXNzGNIJIAEoDV' - 'INdGNwSW5mb0Fkdk1zcxIvChN0Y3BfaW5mb19yZW9yZGVyaW5nGNMJIAEoDVIRdGNwSW5mb1Jl' - 'b3JkZXJpbmcSKAoQdGNwX2luZm9fcmN2X3J0dBjUCSABKA1SDXRjcEluZm9SY3ZSdHQSLAoSdG' - 'NwX2luZm9fcmN2X3NwYWNlGNUJIAEoDVIPdGNwSW5mb1JjdlNwYWNlEjQKFnRjcF9pbmZvX3Rv' - 'dGFsX3JldHJhbnMY1gkgASgNUhN0Y3BJbmZvVG90YWxSZXRyYW5zEjAKFHRjcF9pbmZvX3BhY2' - 'luZ19yYXRlGNcJIAEoBFIRdGNwSW5mb1BhY2luZ1JhdGUSNwoYdGNwX2luZm9fbWF4X3BhY2lu' - 'Z19yYXRlGNgJIAEoBFIUdGNwSW5mb01heFBhY2luZ1JhdGUSMAoUdGNwX2luZm9fYnl0ZXNfYW' - 'NrZWQY2QkgASgEUhF0Y3BJbmZvQnl0ZXNBY2tlZBI2Chd0Y3BfaW5mb19ieXRlc19yZWNlaXZl' - 'ZBjaCSABKARSFHRjcEluZm9CeXRlc1JlY2VpdmVkEioKEXRjcF9pbmZvX3NlZ3Nfb3V0GNsJIA' - 'EoDVIOdGNwSW5mb1NlZ3NPdXQSKAoQdGNwX2luZm9fc2Vnc19pbhjcCSABKA1SDXRjcEluZm9T' - 'ZWdzSW4SNQoXdGNwX2luZm9fbm90X3NlbnRfYnl0ZXMY3QkgASgNUhN0Y3BJbmZvTm90U2VudE' - 'J5dGVzEigKEHRjcF9pbmZvX21pbl9ydHQY3gkgASgNUg10Y3BJbmZvTWluUnR0EjEKFXRjcF9p' - 'bmZvX2RhdGFfc2Vnc19pbhjfCSABKA1SEXRjcEluZm9EYXRhU2Vnc0luEjMKFnRjcF9pbmZvX2' - 'RhdGFfc2Vnc19vdXQY4AkgASgNUhJ0Y3BJbmZvRGF0YVNlZ3NPdXQSNAoWdGNwX2luZm9fZGVs' - 'aXZlcnlfcmF0ZRjhCSABKARSE3RjcEluZm9EZWxpdmVyeVJhdGUSLAoSdGNwX2luZm9fYnVzeV' - '90aW1lGOIJIAEoBFIPdGNwSW5mb0J1c3lUaW1lEjIKFXRjcF9pbmZvX3J3bmRfbGltaXRlZBjj' - 'CSABKARSEnRjcEluZm9Sd25kTGltaXRlZBI2Chd0Y3BfaW5mb19zbmRidWZfbGltaXRlZBjkCS' - 'ABKARSFHRjcEluZm9TbmRidWZMaW1pdGVkEi0KEnRjcF9pbmZvX2RlbGl2ZXJlZBjlCSABKA1S' - 'EHRjcEluZm9EZWxpdmVyZWQSMgoVdGNwX2luZm9fZGVsaXZlcmVkX2NlGOYJIAEoDVISdGNwSW' - '5mb0RlbGl2ZXJlZENlEi4KE3RjcF9pbmZvX2J5dGVzX3NlbnQY5wkgASgEUhB0Y3BJbmZvQnl0' - 'ZXNTZW50EjQKFnRjcF9pbmZvX2J5dGVzX3JldHJhbnMY6AkgASgEUhN0Y3BJbmZvQnl0ZXNSZX' - 'RyYW5zEi4KE3RjcF9pbmZvX2RzYWNrX2R1cHMY6QkgASgNUhB0Y3BJbmZvRHNhY2tEdXBzEi4K' - 'E3RjcF9pbmZvX3Jlb3JkX3NlZW4Y6gkgASgNUhB0Y3BJbmZvUmVvcmRTZWVuEjAKFHRjcF9pbm' - 'ZvX3Jjdl9vb29wYWNrGOsJIAEoDVIRdGNwSW5mb1Jjdk9vb3BhY2sSKAoQdGNwX2luZm9fc25k' - 'X3duZBjsCSABKA1SDXRjcEluZm9TbmRXbmQSKAoQdGNwX2luZm9fcmN2X3duZBjtCSABKA1SDX' - 'RjcEluZm9SY3ZXbmQSJwoPdGNwX2luZm9fcmVoYXNoGO4JIAEoDVINdGNwSW5mb1JlaGFzaBIs' - 'ChJ0Y3BfaW5mb190b3RhbF9ydG8Y7wkgASgNUg90Y3BJbmZvVG90YWxSdG8SQQoddGNwX2luZm' - '9fdG90YWxfcnRvX3JlY292ZXJpZXMY8AkgASgNUhl0Y3BJbmZvVG90YWxSdG9SZWNvdmVyaWVz' - 'EjUKF3RjcF9pbmZvX3RvdGFsX3J0b190aW1lGPEJIAEoDVITdGNwSW5mb1RvdGFsUnRvVGltZR' - 'I/Chtjb25nZXN0aW9uX2FsZ29yaXRobV9zdHJpbmcYlAogASgJUhljb25nZXN0aW9uQWxnb3Jp' - 'dGhtU3RyaW5nEnQKGWNvbmdlc3Rpb25fYWxnb3JpdGhtX2VudW0YlQogASgOMjcueHRjcF9mbG' - 'F0X3JlY29yZC52MS5YdGNwRmxhdFJlY29yZC5Db25nZXN0aW9uQWxnb3JpdGhtUhdjb25nZXN0' - 'aW9uQWxnb3JpdGhtRW51bRInCg90eXBlX29mX3NlcnZpY2UY+QogASgNUg10eXBlT2ZTZXJ2aW' - 'NlEiQKDXRyYWZmaWNfY2xhc3MY+gogASgNUgx0cmFmZmljQ2xhc3MSMwoWc2tfbWVtX2luZm9f' - 'cm1lbV9hbGxvYxjdCyABKA1SEnNrTWVtSW5mb1JtZW1BbGxvYxItChNza19tZW1faW5mb19yY3' - 'ZfYnVmGN4LIAEoDVIPc2tNZW1JbmZvUmN2QnVmEjMKFnNrX21lbV9pbmZvX3dtZW1fYWxsb2MY' - '3wsgASgNUhJza01lbUluZm9XbWVtQWxsb2MSLQoTc2tfbWVtX2luZm9fc25kX2J1ZhjgCyABKA' - '1SD3NrTWVtSW5mb1NuZEJ1ZhIxChVza19tZW1faW5mb19md2RfYWxsb2MY4QsgASgNUhFza01l' - 'bUluZm9Gd2RBbGxvYxI1Chdza19tZW1faW5mb193bWVtX3F1ZXVlZBjiCyABKA1SE3NrTWVtSW' - '5mb1dtZW1RdWV1ZWQSLAoSc2tfbWVtX2luZm9fb3B0bWVtGOMLIAEoDVIPc2tNZW1JbmZvT3B0' - 'bWVtEi4KE3NrX21lbV9pbmZvX2JhY2tsb2cY5AsgASgNUhBza01lbUluZm9CYWNrbG9nEioKEX' - 'NrX21lbV9pbmZvX2Ryb3BzGOULIAEoDVIOc2tNZW1JbmZvRHJvcHMSJgoOc2h1dGRvd25fc3Rh' - 'dGUYwAwgASgNUg1zaHV0ZG93blN0YXRlEi0KEnZlZ2FzX2luZm9fZW5hYmxlZBilDSABKA1SEH' - 'ZlZ2FzSW5mb0VuYWJsZWQSLAoSdmVnYXNfaW5mb19ydHRfY250GKYNIAEoDVIPdmVnYXNJbmZv' - 'UnR0Q250EiUKDnZlZ2FzX2luZm9fcnR0GKcNIAEoDVIMdmVnYXNJbmZvUnR0EiwKEnZlZ2FzX2' - 'luZm9fbWluX3J0dBioDSABKA1SD3ZlZ2FzSW5mb01pblJ0dBItChJkY3RjcF9pbmZvX2VuYWJs' - 'ZWQYiQ4gASgNUhBkY3RjcEluZm9FbmFibGVkEi4KE2RjdGNwX2luZm9fY2Vfc3RhdGUYig4gAS' - 'gNUhBkY3RjcEluZm9DZVN0YXRlEikKEGRjdGNwX2luZm9fYWxwaGEYiw4gASgNUg5kY3RjcElu' - 'Zm9BbHBoYRIqChFkY3RjcF9pbmZvX2FiX2VjbhiMDiABKA1SDmRjdGNwSW5mb0FiRWNuEioKEW' - 'RjdGNwX2luZm9fYWJfdG90GI0OIAEoDVIOZGN0Y3BJbmZvQWJUb3QSJAoOYmJyX2luZm9fYndf' - 'bG8Y7Q4gASgNUgtiYnJJbmZvQndMbxIkCg5iYnJfaW5mb19id19oaRjuDiABKA1SC2JickluZm' - '9Cd0hpEigKEGJicl9pbmZvX21pbl9ydHQY7w4gASgNUg1iYnJJbmZvTWluUnR0EjAKFGJicl9p' - 'bmZvX3BhY2luZ19nYWluGPAOIAEoDVIRYmJySW5mb1BhY2luZ0dhaW4SLAoSYmJyX2luZm9fY3' - 'duZF9nYWluGPEOIAEoDVIPYmJySW5mb0N3bmRHYWluEhoKCGNsYXNzX2lkGNEPIAEoDVIHY2xh' - 'c3NJZBIaCghzb2NrX29wdBjSDyABKA1SB3NvY2tPcHQSGAoHY19ncm91cBi3ECABKARSBmNHcm' - '91cCKZAgoTQ29uZ2VzdGlvbkFsZ29yaXRobRIkCiBDT05HRVNUSU9OX0FMR09SSVRITV9VTlNQ' - 'RUNJRklFRBAAEh4KGkNPTkdFU1RJT05fQUxHT1JJVEhNX0NVQklDEAESHgoaQ09OR0VTVElPTl' - '9BTEdPUklUSE1fRENUQ1AQAhIeChpDT05HRVNUSU9OX0FMR09SSVRITV9WRUdBUxADEh8KG0NP' - 'TkdFU1RJT05fQUxHT1JJVEhNX1BSQUdVRRAEEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JCUj' - 'EQBRIdChlDT05HRVNUSU9OX0FMR09SSVRITV9CQlIyEAYSHQoZQ09OR0VTVElPTl9BTEdPUklU' - 'SE1fQkJSMxAH'); + 'gJUiFpbmV0RGlhZ01zZ1NvY2tldERlc3ROZXR3b3JrT3duZXISeAoiaW5ldF9kaWFnX21zZ19z' + 'b2NrZXRfZGVzdF9sb2NhbGl0eRj7ByABKA4yLC54dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbG' + 'F0UmVjb3JkLkxvY2FsaXR5Uh1pbmV0RGlhZ01zZ1NvY2tldERlc3RMb2NhbGl0eRIjCg1tZW1f' + 'aW5mb19ybWVtGM0IIAEoDVILbWVtSW5mb1JtZW0SIwoNbWVtX2luZm9fd21lbRjOCCABKA1SC2' + '1lbUluZm9XbWVtEiMKDW1lbV9pbmZvX2ZtZW0YzwggASgNUgttZW1JbmZvRm1lbRIjCg1tZW1f' + 'aW5mb190bWVtGNAIIAEoDVILbWVtSW5mb1RtZW0SJQoOdGNwX2luZm9fc3RhdGUYsQkgASgNUg' + 'x0Y3BJbmZvU3RhdGUSKgoRdGNwX2luZm9fY2Ffc3RhdGUYsgkgASgNUg50Y3BJbmZvQ2FTdGF0' + 'ZRIxChR0Y3BfaW5mb19yZXRyYW5zbWl0cxizCSABKA1SEnRjcEluZm9SZXRyYW5zbWl0cxInCg' + '90Y3BfaW5mb19wcm9iZXMYtAkgASgNUg10Y3BJbmZvUHJvYmVzEikKEHRjcF9pbmZvX2JhY2tv' + 'ZmYYtQkgASgNUg50Y3BJbmZvQmFja29mZhIpChB0Y3BfaW5mb19vcHRpb25zGLYJIAEoDVIOdG' + 'NwSW5mb09wdGlvbnMSLgoTdGNwX2luZm9fc2VuZF9zY2FsZRi3CSABKA1SEHRjcEluZm9TZW5k' + 'U2NhbGUSLAoSdGNwX2luZm9fcmN2X3NjYWxlGLgJIAEoDVIPdGNwSW5mb1JjdlNjYWxlEkoKIn' + 'RjcF9pbmZvX2RlbGl2ZXJ5X3JhdGVfYXBwX2xpbWl0ZWQYuQkgASgNUh10Y3BJbmZvRGVsaXZl' + 'cnlSYXRlQXBwTGltaXRlZBJGCiB0Y3BfaW5mb19mYXN0X29wZW5fY2xpZW50X2ZhaWxlZBi6CS' + 'ABKA1SG3RjcEluZm9GYXN0T3BlbkNsaWVudEZhaWxlZBIhCgx0Y3BfaW5mb19ydG8YvwkgASgN' + 'Ugp0Y3BJbmZvUnRvEiEKDHRjcF9pbmZvX2F0bxjACSABKA1SCnRjcEluZm9BdG8SKAoQdGNwX2' + 'luZm9fc25kX21zcxjBCSABKA1SDXRjcEluZm9TbmRNc3MSKAoQdGNwX2luZm9fcmN2X21zcxjC' + 'CSABKA1SDXRjcEluZm9SY3ZNc3MSKQoQdGNwX2luZm9fdW5hY2tlZBjDCSABKA1SDnRjcEluZm' + '9VbmFja2VkEicKD3RjcF9pbmZvX3NhY2tlZBjECSABKA1SDXRjcEluZm9TYWNrZWQSIwoNdGNw' + 'X2luZm9fbG9zdBjFCSABKA1SC3RjcEluZm9Mb3N0EikKEHRjcF9pbmZvX3JldHJhbnMYxgkgAS' + 'gNUg50Y3BJbmZvUmV0cmFucxIpChB0Y3BfaW5mb19mYWNrZXRzGMcJIAEoDVIOdGNwSW5mb0Zh' + 'Y2tldHMSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3NlbnQYyAkgASgNUhN0Y3BJbmZvTGFzdERhdG' + 'FTZW50EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3NlbnQYyQkgASgNUhJ0Y3BJbmZvTGFzdEFja1Nl' + 'bnQSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3JlY3YYygkgASgNUhN0Y3BJbmZvTGFzdERhdGFSZW' + 'N2EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3JlY3YYywkgASgNUhJ0Y3BJbmZvTGFzdEFja1JlY3YS' + 'IwoNdGNwX2luZm9fcG10dRjMCSABKA1SC3RjcEluZm9QbXR1EjIKFXRjcF9pbmZvX3Jjdl9zc3' + 'RocmVzaBjNCSABKA1SEnRjcEluZm9SY3ZTc3RocmVzaBIhCgx0Y3BfaW5mb19ydHQYzgkgASgN' + 'Ugp0Y3BJbmZvUnR0EigKEHRjcF9pbmZvX3J0dF92YXIYzwkgASgNUg10Y3BJbmZvUnR0VmFyEj' + 'IKFXRjcF9pbmZvX3NuZF9zc3RocmVzaBjQCSABKA1SEnRjcEluZm9TbmRTc3RocmVzaBIqChF0' + 'Y3BfaW5mb19zbmRfY3duZBjRCSABKA1SDnRjcEluZm9TbmRDd25kEigKEHRjcF9pbmZvX2Fkdl' + '9tc3MY0gkgASgNUg10Y3BJbmZvQWR2TXNzEi8KE3RjcF9pbmZvX3Jlb3JkZXJpbmcY0wkgASgN' + 'UhF0Y3BJbmZvUmVvcmRlcmluZxIoChB0Y3BfaW5mb19yY3ZfcnR0GNQJIAEoDVINdGNwSW5mb1' + 'JjdlJ0dBIsChJ0Y3BfaW5mb19yY3Zfc3BhY2UY1QkgASgNUg90Y3BJbmZvUmN2U3BhY2USNAoW' + 'dGNwX2luZm9fdG90YWxfcmV0cmFucxjWCSABKA1SE3RjcEluZm9Ub3RhbFJldHJhbnMSMAoUdG' + 'NwX2luZm9fcGFjaW5nX3JhdGUY1wkgASgEUhF0Y3BJbmZvUGFjaW5nUmF0ZRI3Chh0Y3BfaW5m' + 'b19tYXhfcGFjaW5nX3JhdGUY2AkgASgEUhR0Y3BJbmZvTWF4UGFjaW5nUmF0ZRIwChR0Y3BfaW' + '5mb19ieXRlc19hY2tlZBjZCSABKARSEXRjcEluZm9CeXRlc0Fja2VkEjYKF3RjcF9pbmZvX2J5' + 'dGVzX3JlY2VpdmVkGNoJIAEoBFIUdGNwSW5mb0J5dGVzUmVjZWl2ZWQSKgoRdGNwX2luZm9fc2' + 'Vnc19vdXQY2wkgASgNUg50Y3BJbmZvU2Vnc091dBIoChB0Y3BfaW5mb19zZWdzX2luGNwJIAEo' + 'DVINdGNwSW5mb1NlZ3NJbhI1Chd0Y3BfaW5mb19ub3Rfc2VudF9ieXRlcxjdCSABKA1SE3RjcE' + 'luZm9Ob3RTZW50Qnl0ZXMSKAoQdGNwX2luZm9fbWluX3J0dBjeCSABKA1SDXRjcEluZm9NaW5S' + 'dHQSMQoVdGNwX2luZm9fZGF0YV9zZWdzX2luGN8JIAEoDVIRdGNwSW5mb0RhdGFTZWdzSW4SMw' + 'oWdGNwX2luZm9fZGF0YV9zZWdzX291dBjgCSABKA1SEnRjcEluZm9EYXRhU2Vnc091dBI0ChZ0' + 'Y3BfaW5mb19kZWxpdmVyeV9yYXRlGOEJIAEoBFITdGNwSW5mb0RlbGl2ZXJ5UmF0ZRIsChJ0Y3' + 'BfaW5mb19idXN5X3RpbWUY4gkgASgEUg90Y3BJbmZvQnVzeVRpbWUSMgoVdGNwX2luZm9fcndu' + 'ZF9saW1pdGVkGOMJIAEoBFISdGNwSW5mb1J3bmRMaW1pdGVkEjYKF3RjcF9pbmZvX3NuZGJ1Zl' + '9saW1pdGVkGOQJIAEoBFIUdGNwSW5mb1NuZGJ1ZkxpbWl0ZWQSLQoSdGNwX2luZm9fZGVsaXZl' + 'cmVkGOUJIAEoDVIQdGNwSW5mb0RlbGl2ZXJlZBIyChV0Y3BfaW5mb19kZWxpdmVyZWRfY2UY5g' + 'kgASgNUhJ0Y3BJbmZvRGVsaXZlcmVkQ2USLgoTdGNwX2luZm9fYnl0ZXNfc2VudBjnCSABKARS' + 'EHRjcEluZm9CeXRlc1NlbnQSNAoWdGNwX2luZm9fYnl0ZXNfcmV0cmFucxjoCSABKARSE3RjcE' + 'luZm9CeXRlc1JldHJhbnMSLgoTdGNwX2luZm9fZHNhY2tfZHVwcxjpCSABKA1SEHRjcEluZm9E' + 'c2Fja0R1cHMSLgoTdGNwX2luZm9fcmVvcmRfc2VlbhjqCSABKA1SEHRjcEluZm9SZW9yZFNlZW' + '4SMAoUdGNwX2luZm9fcmN2X29vb3BhY2sY6wkgASgNUhF0Y3BJbmZvUmN2T29vcGFjaxIoChB0' + 'Y3BfaW5mb19zbmRfd25kGOwJIAEoDVINdGNwSW5mb1NuZFduZBIoChB0Y3BfaW5mb19yY3Zfd2' + '5kGO0JIAEoDVINdGNwSW5mb1JjdlduZBInCg90Y3BfaW5mb19yZWhhc2gY7gkgASgNUg10Y3BJ' + 'bmZvUmVoYXNoEiwKEnRjcF9pbmZvX3RvdGFsX3J0bxjvCSABKA1SD3RjcEluZm9Ub3RhbFJ0bx' + 'JBCh10Y3BfaW5mb190b3RhbF9ydG9fcmVjb3ZlcmllcxjwCSABKA1SGXRjcEluZm9Ub3RhbFJ0' + 'b1JlY292ZXJpZXMSNQoXdGNwX2luZm9fdG90YWxfcnRvX3RpbWUY8QkgASgNUhN0Y3BJbmZvVG' + '90YWxSdG9UaW1lEj8KG2Nvbmdlc3Rpb25fYWxnb3JpdGhtX3N0cmluZxiUCiABKAlSGWNvbmdl' + 'c3Rpb25BbGdvcml0aG1TdHJpbmcSdAoZY29uZ2VzdGlvbl9hbGdvcml0aG1fZW51bRiVCiABKA' + '4yNy54dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbGF0UmVjb3JkLkNvbmdlc3Rpb25BbGdvcml0' + 'aG1SF2Nvbmdlc3Rpb25BbGdvcml0aG1FbnVtEicKD3R5cGVfb2Zfc2VydmljZRj5CiABKA1SDX' + 'R5cGVPZlNlcnZpY2USJAoNdHJhZmZpY19jbGFzcxj6CiABKA1SDHRyYWZmaWNDbGFzcxIzChZz' + 'a19tZW1faW5mb19ybWVtX2FsbG9jGN0LIAEoDVISc2tNZW1JbmZvUm1lbUFsbG9jEi0KE3NrX2' + '1lbV9pbmZvX3Jjdl9idWYY3gsgASgNUg9za01lbUluZm9SY3ZCdWYSMwoWc2tfbWVtX2luZm9f' + 'd21lbV9hbGxvYxjfCyABKA1SEnNrTWVtSW5mb1dtZW1BbGxvYxItChNza19tZW1faW5mb19zbm' + 'RfYnVmGOALIAEoDVIPc2tNZW1JbmZvU25kQnVmEjEKFXNrX21lbV9pbmZvX2Z3ZF9hbGxvYxjh' + 'CyABKA1SEXNrTWVtSW5mb0Z3ZEFsbG9jEjUKF3NrX21lbV9pbmZvX3dtZW1fcXVldWVkGOILIA' + 'EoDVITc2tNZW1JbmZvV21lbVF1ZXVlZBIsChJza19tZW1faW5mb19vcHRtZW0Y4wsgASgNUg9z' + 'a01lbUluZm9PcHRtZW0SLgoTc2tfbWVtX2luZm9fYmFja2xvZxjkCyABKA1SEHNrTWVtSW5mb0' + 'JhY2tsb2cSKgoRc2tfbWVtX2luZm9fZHJvcHMY5QsgASgNUg5za01lbUluZm9Ecm9wcxImCg5z' + 'aHV0ZG93bl9zdGF0ZRjADCABKA1SDXNodXRkb3duU3RhdGUSLQoSdmVnYXNfaW5mb19lbmFibG' + 'VkGKUNIAEoDVIQdmVnYXNJbmZvRW5hYmxlZBIsChJ2ZWdhc19pbmZvX3J0dF9jbnQYpg0gASgN' + 'Ug92ZWdhc0luZm9SdHRDbnQSJQoOdmVnYXNfaW5mb19ydHQYpw0gASgNUgx2ZWdhc0luZm9SdH' + 'QSLAoSdmVnYXNfaW5mb19taW5fcnR0GKgNIAEoDVIPdmVnYXNJbmZvTWluUnR0Ei0KEmRjdGNw' + 'X2luZm9fZW5hYmxlZBiJDiABKA1SEGRjdGNwSW5mb0VuYWJsZWQSLgoTZGN0Y3BfaW5mb19jZV' + '9zdGF0ZRiKDiABKA1SEGRjdGNwSW5mb0NlU3RhdGUSKQoQZGN0Y3BfaW5mb19hbHBoYRiLDiAB' + 'KA1SDmRjdGNwSW5mb0FscGhhEioKEWRjdGNwX2luZm9fYWJfZWNuGIwOIAEoDVIOZGN0Y3BJbm' + 'ZvQWJFY24SKgoRZGN0Y3BfaW5mb19hYl90b3QYjQ4gASgNUg5kY3RjcEluZm9BYlRvdBIkCg5i' + 'YnJfaW5mb19id19sbxjtDiABKA1SC2JickluZm9Cd0xvEiQKDmJicl9pbmZvX2J3X2hpGO4OIA' + 'EoDVILYmJySW5mb0J3SGkSKAoQYmJyX2luZm9fbWluX3J0dBjvDiABKA1SDWJickluZm9NaW5S' + 'dHQSMAoUYmJyX2luZm9fcGFjaW5nX2dhaW4Y8A4gASgNUhFiYnJJbmZvUGFjaW5nR2FpbhIsCh' + 'JiYnJfaW5mb19jd25kX2dhaW4Y8Q4gASgNUg9iYnJJbmZvQ3duZEdhaW4SGgoIY2xhc3NfaWQY' + '0Q8gASgNUgdjbGFzc0lkEhoKCHNvY2tfb3B0GNIPIAEoDVIHc29ja09wdBIYCgdjX2dyb3VwGL' + 'cQIAEoBFIGY0dyb3VwImcKCExvY2FsaXR5EhgKFExPQ0FMSVRZX1VOU1BFQ0lGSUVEEAASEQoN' + 'TE9DQUxJVFlfU0VMRhABEhkKFUxPQ0FMSVRZX0xPQ0FMX1NVQk5FVBACEhMKD0xPQ0FMSVRZX1' + 'JFTU9URRADIpkCChNDb25nZXN0aW9uQWxnb3JpdGhtEiQKIENPTkdFU1RJT05fQUxHT1JJVEhN' + 'X1VOU1BFQ0lGSUVEEAASHgoaQ09OR0VTVElPTl9BTEdPUklUSE1fQ1VCSUMQARIeChpDT05HRV' + 'NUSU9OX0FMR09SSVRITV9EQ1RDUBACEh4KGkNPTkdFU1RJT05fQUxHT1JJVEhNX1ZFR0FTEAMS' + 'HwobQ09OR0VTVElPTl9BTEdPUklUSE1fUFJBR1VFEAQSHQoZQ09OR0VTVElPTl9BTEdPUklUSE' + '1fQkJSMRAFEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JCUjIQBhIdChlDT05HRVNUSU9OX0FM' + 'R09SSVRITV9CQlIzEAc='); @$core.Deprecated('Use flatRecordsRequestDescriptor instead') const FlatRecordsRequest$json = { diff --git a/gen/go/xtcp_config/xtcp_config.pb.go b/gen/go/xtcp_config/xtcp_config.pb.go index 83c5811..dac3830 100644 --- a/gen/go/xtcp_config/xtcp_config.pb.go +++ b/gen/go/xtcp_config/xtcp_config.pb.go @@ -983,8 +983,20 @@ type XtcpConfig struct { // How often to reload asn_db_path in the background so a refreshed artifact // is picked up without a restart. 0 = load once at startup, never reload. AsnRefreshInterval *durationpb.Duration `protobuf:"bytes,241,opt,name=asn_refresh_interval,json=asnRefreshInterval,proto3" json:"asn_refresh_interval,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Classify the destination IP's locality (field 1019) — self / + // connected-subnet / remote — from each monitored network namespace's local + // addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs + // BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: + // a per-namespace discovery failure just leaves that namespace's sockets + // unclassified. Default false. + EnrichLocalityEnable bool `protobuf:"varint,242,opt,name=enrich_locality_enable,json=enrichLocalityEnable,proto3" json:"enrich_locality_enable,omitempty"` + // How often to re-discover local addresses/routes per namespace so runtime + // changes (interfaces up/down, routes added) are picked up. Newly-appeared + // namespaces are always snapshotted on the next reconcile regardless. 0 = + // discover once per namespace, never refresh. + LocalityRefreshInterval *durationpb.Duration `protobuf:"bytes,243,opt,name=locality_refresh_interval,json=localityRefreshInterval,proto3" json:"locality_refresh_interval,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *XtcpConfig) Reset() { @@ -1500,6 +1512,20 @@ func (x *XtcpConfig) GetAsnRefreshInterval() *durationpb.Duration { return nil } +func (x *XtcpConfig) GetEnrichLocalityEnable() bool { + if x != nil { + return x.EnrichLocalityEnable + } + return false +} + +func (x *XtcpConfig) GetLocalityRefreshInterval() *durationpb.Duration { + if x != nil { + return x.LocalityRefreshInterval + } + return nil +} + type EnabledDeserializers struct { state protoimpl.MessageState `protogen:"open.v1"` Enabled map[string]bool `protobuf:"bytes,1,rep,name=enabled,proto3" json:"enabled,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` @@ -1588,7 +1614,7 @@ const file_xtcp_config_v1_xtcp_config_proto_rawDesc = "" + "\x1denvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1aenvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n" + "\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n" + "\x18SetEnvelopeFlushResponse\x122\n" + - "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\x9f\x1f\n" + + "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\xae \n" + "\n" + "XtcpConfig\x12F\n" + "\x17nl_timeout_milliseconds\x18\n" + @@ -1681,7 +1707,9 @@ const file_xtcp_config_v1_xtcp_config_proto_rawDesc = "" + "\rpopulate_nsid\x18\xee\x01 \x01(\bR\fpopulateNsid\x12+\n" + "\x11enrich_asn_enable\x18\xef\x01 \x01(\bR\x0fenrichAsnEnable\x12)\n" + "\vasn_db_path\x18\xf0\x01 \x01(\tB\b\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n" + - "\x14asn_refresh_interval\x18\xf1\x01 \x01(\v2\x19.google.protobuf.DurationR\x12asnRefreshInterval:s\xbaHp\x1an\n" + + "\x14asn_refresh_interval\x18\xf1\x01 \x01(\v2\x19.google.protobuf.DurationR\x12asnRefreshInterval\x125\n" + + "\x16enrich_locality_enable\x18\xf2\x01 \x01(\bR\x14enrichLocalityEnable\x12V\n" + + "\x19locality_refresh_interval\x18\xf3\x01 \x01(\v2\x19.google.protobuf.DurationR\x17localityRefreshInterval:s\xbaHp\x1an\n" + "\x0fXtcpConfig.poll\x122Poll timeout must be less than poll poll_frequency\x1a'this.poll_frequency > this.poll_timeout\"\x9f\x01\n" + "\x14EnabledDeserializers\x12K\n" + "\aenabled\x18\x01 \x03(\v21.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\aenabled\x1a:\n" + @@ -1751,26 +1779,27 @@ var file_xtcp_config_v1_xtcp_config_proto_depIdxs = []int32{ 17, // 16: xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap:type_name -> google.protobuf.Duration 17, // 17: xtcp_config.v1.XtcpConfig.reconcile_frequency:type_name -> google.protobuf.Duration 17, // 18: xtcp_config.v1.XtcpConfig.asn_refresh_interval:type_name -> google.protobuf.Duration - 16, // 19: xtcp_config.v1.EnabledDeserializers.enabled:type_name -> xtcp_config.v1.EnabledDeserializers.EnabledEntry - 0, // 20: xtcp_config.v1.ConfigService.Get:input_type -> xtcp_config.v1.GetRequest - 2, // 21: xtcp_config.v1.ConfigService.Set:input_type -> xtcp_config.v1.SetRequest - 4, // 22: xtcp_config.v1.ConfigService.SetPollFrequency:input_type -> xtcp_config.v1.SetPollFrequencyRequest - 6, // 23: xtcp_config.v1.ConfigService.TriggerPoll:input_type -> xtcp_config.v1.TriggerPollRequest - 8, // 24: xtcp_config.v1.ConfigService.TriggerPollBurst:input_type -> xtcp_config.v1.TriggerPollBurstRequest - 10, // 25: xtcp_config.v1.ConfigService.SetS3Upload:input_type -> xtcp_config.v1.SetS3UploadRequest - 12, // 26: xtcp_config.v1.ConfigService.SetEnvelopeFlush:input_type -> xtcp_config.v1.SetEnvelopeFlushRequest - 1, // 27: xtcp_config.v1.ConfigService.Get:output_type -> xtcp_config.v1.GetResponse - 3, // 28: xtcp_config.v1.ConfigService.Set:output_type -> xtcp_config.v1.SetResponse - 5, // 29: xtcp_config.v1.ConfigService.SetPollFrequency:output_type -> xtcp_config.v1.SetPollFrequencyResponse - 7, // 30: xtcp_config.v1.ConfigService.TriggerPoll:output_type -> xtcp_config.v1.TriggerPollResponse - 9, // 31: xtcp_config.v1.ConfigService.TriggerPollBurst:output_type -> xtcp_config.v1.TriggerPollBurstResponse - 11, // 32: xtcp_config.v1.ConfigService.SetS3Upload:output_type -> xtcp_config.v1.SetS3UploadResponse - 13, // 33: xtcp_config.v1.ConfigService.SetEnvelopeFlush:output_type -> xtcp_config.v1.SetEnvelopeFlushResponse - 27, // [27:34] is the sub-list for method output_type - 20, // [20:27] is the sub-list for method input_type - 20, // [20:20] is the sub-list for extension type_name - 20, // [20:20] is the sub-list for extension extendee - 0, // [0:20] is the sub-list for field type_name + 17, // 19: xtcp_config.v1.XtcpConfig.locality_refresh_interval:type_name -> google.protobuf.Duration + 16, // 20: xtcp_config.v1.EnabledDeserializers.enabled:type_name -> xtcp_config.v1.EnabledDeserializers.EnabledEntry + 0, // 21: xtcp_config.v1.ConfigService.Get:input_type -> xtcp_config.v1.GetRequest + 2, // 22: xtcp_config.v1.ConfigService.Set:input_type -> xtcp_config.v1.SetRequest + 4, // 23: xtcp_config.v1.ConfigService.SetPollFrequency:input_type -> xtcp_config.v1.SetPollFrequencyRequest + 6, // 24: xtcp_config.v1.ConfigService.TriggerPoll:input_type -> xtcp_config.v1.TriggerPollRequest + 8, // 25: xtcp_config.v1.ConfigService.TriggerPollBurst:input_type -> xtcp_config.v1.TriggerPollBurstRequest + 10, // 26: xtcp_config.v1.ConfigService.SetS3Upload:input_type -> xtcp_config.v1.SetS3UploadRequest + 12, // 27: xtcp_config.v1.ConfigService.SetEnvelopeFlush:input_type -> xtcp_config.v1.SetEnvelopeFlushRequest + 1, // 28: xtcp_config.v1.ConfigService.Get:output_type -> xtcp_config.v1.GetResponse + 3, // 29: xtcp_config.v1.ConfigService.Set:output_type -> xtcp_config.v1.SetResponse + 5, // 30: xtcp_config.v1.ConfigService.SetPollFrequency:output_type -> xtcp_config.v1.SetPollFrequencyResponse + 7, // 31: xtcp_config.v1.ConfigService.TriggerPoll:output_type -> xtcp_config.v1.TriggerPollResponse + 9, // 32: xtcp_config.v1.ConfigService.TriggerPollBurst:output_type -> xtcp_config.v1.TriggerPollBurstResponse + 11, // 33: xtcp_config.v1.ConfigService.SetS3Upload:output_type -> xtcp_config.v1.SetS3UploadResponse + 13, // 34: xtcp_config.v1.ConfigService.SetEnvelopeFlush:output_type -> xtcp_config.v1.SetEnvelopeFlushResponse + 28, // [28:35] is the sub-list for method output_type + 21, // [21:28] is the sub-list for method input_type + 21, // [21:21] is the sub-list for extension type_name + 21, // [21:21] is the sub-list for extension extendee + 0, // [0:21] is the sub-list for field type_name } func init() { file_xtcp_config_v1_xtcp_config_proto_init() } diff --git a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go index 56ee47f..ef612a9 100644 --- a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go +++ b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go @@ -659,6 +659,30 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.LocalityRefreshInterval != nil { + size, err := (*durationpb.Duration)(m.LocalityRefreshInterval).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xf + i-- + dAtA[i] = 0x9a + } + if m.EnrichLocalityEnable { + i-- + if m.EnrichLocalityEnable { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0xf + i-- + dAtA[i] = 0x90 + } if m.AsnRefreshInterval != nil { size, err := (*durationpb.Duration)(m.AsnRefreshInterval).MarshalToSizedBufferVT(dAtA[:i]) if err != nil { @@ -1785,6 +1809,13 @@ func (m *XtcpConfig) SizeVT() (n int) { l = (*durationpb.Duration)(m.AsnRefreshInterval).SizeVT() n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } + if m.EnrichLocalityEnable { + n += 3 + } + if m.LocalityRefreshInterval != nil { + l = (*durationpb.Duration)(m.LocalityRefreshInterval).SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } n += len(m.unknownFields) return n } @@ -4835,6 +4866,62 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex + case 242: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichLocalityEnable", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnrichLocalityEnable = bool(v != 0) + case 243: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalityRefreshInterval", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LocalityRefreshInterval == nil { + m.LocalityRefreshInterval = &durationpb1.Duration{} + } + if err := (*durationpb.Duration)(m.LocalityRefreshInterval).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go index dde69fd..96170b6 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go @@ -40,6 +40,65 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +// Destination endpoint locality, classified from the socket's own network +// namespace's local addresses + routing table (discovered via rtnetlink, +// see pkg/localnet). Populated by the opt-in locality enricher BEFORE the +// ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, +// so dest_asn (1011) / dest_network_owner (1018) stay empty for them. +// UNSPECIFIED when locality enrichment is disabled or the namespace has no +// snapshot yet. +type XtcpFlatRecord_Locality int32 + +const ( + XtcpFlatRecord_LOCALITY_UNSPECIFIED XtcpFlatRecord_Locality = 0 + XtcpFlatRecord_LOCALITY_SELF XtcpFlatRecord_Locality = 1 // one of this host/namespace's own addresses (or loopback) + XtcpFlatRecord_LOCALITY_LOCAL_SUBNET XtcpFlatRecord_Locality = 2 // on a directly-connected subnet (one L2 hop, no gateway) + XtcpFlatRecord_LOCALITY_REMOTE XtcpFlatRecord_Locality = 3 // reached via a gateway (falls through to ASN lookup) +) + +// Enum value maps for XtcpFlatRecord_Locality. +var ( + XtcpFlatRecord_Locality_name = map[int32]string{ + 0: "LOCALITY_UNSPECIFIED", + 1: "LOCALITY_SELF", + 2: "LOCALITY_LOCAL_SUBNET", + 3: "LOCALITY_REMOTE", + } + XtcpFlatRecord_Locality_value = map[string]int32{ + "LOCALITY_UNSPECIFIED": 0, + "LOCALITY_SELF": 1, + "LOCALITY_LOCAL_SUBNET": 2, + "LOCALITY_REMOTE": 3, + } +) + +func (x XtcpFlatRecord_Locality) Enum() *XtcpFlatRecord_Locality { + p := new(XtcpFlatRecord_Locality) + *p = x + return p +} + +func (x XtcpFlatRecord_Locality) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (XtcpFlatRecord_Locality) Descriptor() protoreflect.EnumDescriptor { + return file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[0].Descriptor() +} + +func (XtcpFlatRecord_Locality) Type() protoreflect.EnumType { + return &file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[0] +} + +func (x XtcpFlatRecord_Locality) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use XtcpFlatRecord_Locality.Descriptor instead. +func (XtcpFlatRecord_Locality) EnumDescriptor() ([]byte, []int) { + return file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDescGZIP(), []int{1, 0} +} + type XtcpFlatRecord_CongestionAlgorithm int32 const ( @@ -88,11 +147,11 @@ func (x XtcpFlatRecord_CongestionAlgorithm) String() string { } func (XtcpFlatRecord_CongestionAlgorithm) Descriptor() protoreflect.EnumDescriptor { - return file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[0].Descriptor() + return file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[1].Descriptor() } func (XtcpFlatRecord_CongestionAlgorithm) Type() protoreflect.EnumType { - return &file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[0] + return &file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes[1] } func (x XtcpFlatRecord_CongestionAlgorithm) Number() protoreflect.EnumNumber { @@ -101,7 +160,7 @@ func (x XtcpFlatRecord_CongestionAlgorithm) Number() protoreflect.EnumNumber { // Deprecated: Use XtcpFlatRecord_CongestionAlgorithm.Descriptor instead. func (XtcpFlatRecord_CongestionAlgorithm) EnumDescriptor() ([]byte, []int) { - return file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDescGZIP(), []int{1, 0} + return file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDescGZIP(), []int{1, 1} } // Envelope is the protobufList wrapper to allow for batch inserts into Clickhouse @@ -269,7 +328,8 @@ type XtcpFlatRecord struct { // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the // destination IP is not in the feed set. - InetDiagMsgSocketDestNetworkOwner string `protobuf:"bytes,1018,opt,name=inet_diag_msg_socket_dest_network_owner,json=inetDiagMsgSocketDestNetworkOwner,proto3" json:"inet_diag_msg_socket_dest_network_owner,omitempty"` + InetDiagMsgSocketDestNetworkOwner string `protobuf:"bytes,1018,opt,name=inet_diag_msg_socket_dest_network_owner,json=inetDiagMsgSocketDestNetworkOwner,proto3" json:"inet_diag_msg_socket_dest_network_owner,omitempty"` + InetDiagMsgSocketDestLocality XtcpFlatRecord_Locality `protobuf:"varint,1019,opt,name=inet_diag_msg_socket_dest_locality,json=inetDiagMsgSocketDestLocality,proto3,enum=xtcp_flat_record.v1.XtcpFlatRecord_Locality" json:"inet_diag_msg_socket_dest_locality,omitempty"` // DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by // default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), // so these ship as 0 on current records. The same values live in sk_mem_info: @@ -847,6 +907,13 @@ func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestNetworkOwner() string { return "" } +func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestLocality() XtcpFlatRecord_Locality { + if x != nil { + return x.InetDiagMsgSocketDestLocality + } + return XtcpFlatRecord_LOCALITY_UNSPECIFIED +} + func (x *XtcpFlatRecord) GetMemInfoRmem() uint32 { if x != nil { return x.MemInfoRmem @@ -1686,7 +1753,7 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n" + "\bEnvelope\x125\n" + "\x03row\x18\n" + - " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xe3<\n" + + " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc6>\n" + "\x0eXtcpFlatRecord\x12%\n" + "\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n" + "\x0edaemon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n" + @@ -1750,7 +1817,8 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x14inet_diag_msg_wqueue\x18\xf7\a \x01(\rR\x11inetDiagMsgWqueue\x12*\n" + "\x11inet_diag_msg_uid\x18\xf8\a \x01(\rR\x0einetDiagMsgUid\x12.\n" + "\x13inet_diag_msg_inode\x18\xf9\a \x01(\rR\x10inetDiagMsgInode\x12S\n" + - "'inet_diag_msg_socket_dest_network_owner\x18\xfa\a \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12#\n" + + "'inet_diag_msg_socket_dest_network_owner\x18\xfa\a \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12x\n" + + "\"inet_diag_msg_socket_dest_locality\x18\xfb\a \x01(\x0e2,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x1dinetDiagMsgSocketDestLocality\x12#\n" + "\rmem_info_rmem\x18\xcd\b \x01(\rR\vmemInfoRmem\x12#\n" + "\rmem_info_wmem\x18\xce\b \x01(\rR\vmemInfoWmem\x12#\n" + "\rmem_info_fmem\x18\xcf\b \x01(\rR\vmemInfoFmem\x12#\n" + @@ -1853,7 +1921,12 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x12bbr_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0fbbrInfoCwndGain\x12\x1a\n" + "\bclass_id\x18\xd1\x0f \x01(\rR\aclassId\x12\x1a\n" + "\bsock_opt\x18\xd2\x0f \x01(\rR\asockOpt\x12\x18\n" + - "\ac_group\x18\xb7\x10 \x01(\x04R\x06cGroup\"\x99\x02\n" + + "\ac_group\x18\xb7\x10 \x01(\x04R\x06cGroup\"g\n" + + "\bLocality\x12\x18\n" + + "\x14LOCALITY_UNSPECIFIED\x10\x00\x12\x11\n" + + "\rLOCALITY_SELF\x10\x01\x12\x19\n" + + "\x15LOCALITY_LOCAL_SUBNET\x10\x02\x12\x13\n" + + "\x0fLOCALITY_REMOTE\x10\x03\"\x99\x02\n" + "\x13CongestionAlgorithm\x12$\n" + " CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n" + "\x1aCONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n" + @@ -1886,31 +1959,33 @@ func file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDescGZIP() []byte { return file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDescData } -var file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_xtcp_flat_record_v1_xtcp_flat_record_proto_enumTypes = make([]protoimpl.EnumInfo, 2) var file_xtcp_flat_record_v1_xtcp_flat_record_proto_msgTypes = make([]protoimpl.MessageInfo, 6) var file_xtcp_flat_record_v1_xtcp_flat_record_proto_goTypes = []any{ - (XtcpFlatRecord_CongestionAlgorithm)(0), // 0: xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm - (*Envelope)(nil), // 1: xtcp_flat_record.v1.Envelope - (*XtcpFlatRecord)(nil), // 2: xtcp_flat_record.v1.XtcpFlatRecord - (*FlatRecordsRequest)(nil), // 3: xtcp_flat_record.v1.FlatRecordsRequest - (*FlatRecordsResponse)(nil), // 4: xtcp_flat_record.v1.FlatRecordsResponse - (*PollFlatRecordsRequest)(nil), // 5: xtcp_flat_record.v1.PollFlatRecordsRequest - (*PollFlatRecordsResponse)(nil), // 6: xtcp_flat_record.v1.PollFlatRecordsResponse + (XtcpFlatRecord_Locality)(0), // 0: xtcp_flat_record.v1.XtcpFlatRecord.Locality + (XtcpFlatRecord_CongestionAlgorithm)(0), // 1: xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm + (*Envelope)(nil), // 2: xtcp_flat_record.v1.Envelope + (*XtcpFlatRecord)(nil), // 3: xtcp_flat_record.v1.XtcpFlatRecord + (*FlatRecordsRequest)(nil), // 4: xtcp_flat_record.v1.FlatRecordsRequest + (*FlatRecordsResponse)(nil), // 5: xtcp_flat_record.v1.FlatRecordsResponse + (*PollFlatRecordsRequest)(nil), // 6: xtcp_flat_record.v1.PollFlatRecordsRequest + (*PollFlatRecordsResponse)(nil), // 7: xtcp_flat_record.v1.PollFlatRecordsResponse } var file_xtcp_flat_record_v1_xtcp_flat_record_proto_depIdxs = []int32{ - 2, // 0: xtcp_flat_record.v1.Envelope.row:type_name -> xtcp_flat_record.v1.XtcpFlatRecord - 0, // 1: xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm - 2, // 2: xtcp_flat_record.v1.FlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord - 2, // 3: xtcp_flat_record.v1.PollFlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord - 3, // 4: xtcp_flat_record.v1.XTCPFlatRecordService.FlatRecords:input_type -> xtcp_flat_record.v1.FlatRecordsRequest - 5, // 5: xtcp_flat_record.v1.XTCPFlatRecordService.PollFlatRecords:input_type -> xtcp_flat_record.v1.PollFlatRecordsRequest - 4, // 6: xtcp_flat_record.v1.XTCPFlatRecordService.FlatRecords:output_type -> xtcp_flat_record.v1.FlatRecordsResponse - 6, // 7: xtcp_flat_record.v1.XTCPFlatRecordService.PollFlatRecords:output_type -> xtcp_flat_record.v1.PollFlatRecordsResponse - 6, // [6:8] is the sub-list for method output_type - 4, // [4:6] is the sub-list for method input_type - 4, // [4:4] is the sub-list for extension type_name - 4, // [4:4] is the sub-list for extension extendee - 0, // [0:4] is the sub-list for field type_name + 3, // 0: xtcp_flat_record.v1.Envelope.row:type_name -> xtcp_flat_record.v1.XtcpFlatRecord + 0, // 1: xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.Locality + 1, // 2: xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm + 3, // 3: xtcp_flat_record.v1.FlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord + 3, // 4: xtcp_flat_record.v1.PollFlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord + 4, // 5: xtcp_flat_record.v1.XTCPFlatRecordService.FlatRecords:input_type -> xtcp_flat_record.v1.FlatRecordsRequest + 6, // 6: xtcp_flat_record.v1.XTCPFlatRecordService.PollFlatRecords:input_type -> xtcp_flat_record.v1.PollFlatRecordsRequest + 5, // 7: xtcp_flat_record.v1.XTCPFlatRecordService.FlatRecords:output_type -> xtcp_flat_record.v1.FlatRecordsResponse + 7, // 8: xtcp_flat_record.v1.XTCPFlatRecordService.PollFlatRecords:output_type -> xtcp_flat_record.v1.PollFlatRecordsResponse + 7, // [7:9] is the sub-list for method output_type + 5, // [5:7] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name } func init() { file_xtcp_flat_record_v1_xtcp_flat_record_proto_init() } @@ -1923,7 +1998,7 @@ func file_xtcp_flat_record_v1_xtcp_flat_record_proto_init() { File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc), len(file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc)), - NumEnums: 1, + NumEnums: 2, NumMessages: 6, NumExtensions: 0, NumServices: 1, diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go index 69a9622..7d03406 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go @@ -769,6 +769,13 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xe8 } + if m.InetDiagMsgSocketDestLocality != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgSocketDestLocality)) + i-- + dAtA[i] = 0x3f + i-- + dAtA[i] = 0xd8 + } if len(m.InetDiagMsgSocketDestNetworkOwner) > 0 { i -= len(m.InetDiagMsgSocketDestNetworkOwner) copy(dAtA[i:], m.InetDiagMsgSocketDestNetworkOwner) @@ -1649,6 +1656,9 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } + if m.InetDiagMsgSocketDestLocality != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgSocketDestLocality)) + } if m.MemInfoRmem != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.MemInfoRmem)) } @@ -3696,6 +3706,25 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } m.InetDiagMsgSocketDestNetworkOwner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 1019: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketDestLocality", wireType) + } + m.InetDiagMsgSocketDestLocality = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.InetDiagMsgSocketDestLocality |= XtcpFlatRecord_Locality(b&0x7F) << shift + if b < 0x80 { + break + } + } case 1101: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MemInfoRmem", wireType) diff --git a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json index a4898ae..aab79a8 100644 --- a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json +++ b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json @@ -720,6 +720,14 @@ "asnRefreshInterval": { "type": "string", "description": "How often to reload asn_db_path in the background so a refreshed artifact\nis picked up without a restart. 0 = load once at startup, never reload." + }, + "enrichLocalityEnable": { + "type": "boolean", + "description": "Classify the destination IP's locality (field 1019) — self /\nconnected-subnet / remote — from each monitored network namespace's local\naddresses + routing table, discovered via rtnetlink (pkg/localnet). Runs\nBEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal:\na per-namespace discovery failure just leaves that namespace's sockets\nunclassified. Default false." + }, + "localityRefreshInterval": { + "type": "string", + "description": "How often to re-discover local addresses/routes per namespace so runtime\nchanges (interfaces up/down, routes added) are picked up. Newly-appeared\nnamespaces are always snapshotted on the next reconcile regardless. 0 =\ndiscover once per namespace, never refresh." } }, "title": "xtcp configuration" diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.py b/gen/python/xtcp_config/v1/xtcp_config_pb2.py index 44f0b05..a471224 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.py +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.py @@ -27,7 +27,7 @@ from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x9f\x1f\n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12+\n\tmax_loops\x18( \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x32 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x33 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x46 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18P \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12.\n\x0bwrite_files\x18Z \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x64 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12(\n\x07modulus\x18n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12+\n\nmarshal_to\x18x \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\x33\n\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12+\n\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12+\n\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12O\n s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12\x38\n\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n\x04\x64\x65st\x18\x82\x01 \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12\x38\n\x10\x64\x65st_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12#\n\x05topic\x18\x8c\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x35\n\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12\x37\n\x10kafka_schema_url\x18\x91\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12`\n\x15kafka_produce_timeout\x18\x96\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12/\n\x0b\x64\x65\x62ug_level\x18\xa0\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x05label\x18\xaa\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\xb4\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12(\n\x08location\x18\xb5\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12(\n\x08hostname\x18\xb6\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12\x33\n\x0e\x64\x61\x65mon_version\x18\xba\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\x39\n\x14resolve_container_id\x18\xb7\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\'\n\x08ipv4_ttl\x18\xb8\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\xb9\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xbe\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12\x62\n\x15\x65nabled_deserializers\x18\xc8\x01 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12\"\n\x08io_uring\x18\xd2\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x46\n\x18io_uring_recv_batch_size\x18\xd3\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x44\n\x17io_uring_cqe_batch_size\x18\xd4\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12(\n\x0b\x63sv_columns\x18\xdc\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x33\n\x0fpoll_jitter_pct\x18\xdd\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12S\n\x11s3_flush_interval\x18\xde\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12:\n\x13s3_flush_jitter_pct\x18\xdf\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12M\n\x1ds3_flush_threshold_jitter_pct\x18\xe0\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x42\n\x16s3_upload_max_attempts\x18\xe1\x01 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Z\n\x15s3_upload_backoff_cap\x18\xe2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12X\n\x13reconcile_frequency\x18\xe3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x33\n\x15reconcile_before_poll\x18\xe4\x01 \x01(\x08R\x13reconcileBeforePoll\x12\x37\n\x17\x65nrich_container_enable\x18\xe6\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xe7\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xe8\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xe9\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xea\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xeb\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xec\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xed\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xee\x01 \x01(\x08R\x0cpopulateNsid\x12+\n\x11\x65nrich_asn_enable\x18\xef\x01 \x01(\x08R\x0f\x65nrichAsnEnable\x12)\n\x0b\x61sn_db_path\x18\xf0\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n\x14\x61sn_refresh_interval\x18\xf1\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x12\x61snRefreshInterval:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xae \n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12+\n\tmax_loops\x18( \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x32 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x33 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x46 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18P \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12.\n\x0bwrite_files\x18Z \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x64 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12(\n\x07modulus\x18n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12+\n\nmarshal_to\x18x \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\x33\n\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12+\n\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12+\n\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12O\n s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12\x38\n\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n\x04\x64\x65st\x18\x82\x01 \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12\x38\n\x10\x64\x65st_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12#\n\x05topic\x18\x8c\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x35\n\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12\x37\n\x10kafka_schema_url\x18\x91\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12`\n\x15kafka_produce_timeout\x18\x96\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12/\n\x0b\x64\x65\x62ug_level\x18\xa0\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x05label\x18\xaa\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\xb4\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12(\n\x08location\x18\xb5\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12(\n\x08hostname\x18\xb6\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12\x33\n\x0e\x64\x61\x65mon_version\x18\xba\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\x39\n\x14resolve_container_id\x18\xb7\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\'\n\x08ipv4_ttl\x18\xb8\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\xb9\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xbe\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12\x62\n\x15\x65nabled_deserializers\x18\xc8\x01 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12\"\n\x08io_uring\x18\xd2\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x46\n\x18io_uring_recv_batch_size\x18\xd3\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x44\n\x17io_uring_cqe_batch_size\x18\xd4\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12(\n\x0b\x63sv_columns\x18\xdc\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x33\n\x0fpoll_jitter_pct\x18\xdd\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12S\n\x11s3_flush_interval\x18\xde\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12:\n\x13s3_flush_jitter_pct\x18\xdf\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12M\n\x1ds3_flush_threshold_jitter_pct\x18\xe0\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x42\n\x16s3_upload_max_attempts\x18\xe1\x01 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Z\n\x15s3_upload_backoff_cap\x18\xe2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12X\n\x13reconcile_frequency\x18\xe3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x33\n\x15reconcile_before_poll\x18\xe4\x01 \x01(\x08R\x13reconcileBeforePoll\x12\x37\n\x17\x65nrich_container_enable\x18\xe6\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xe7\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xe8\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xe9\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xea\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xeb\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xec\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xed\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xee\x01 \x01(\x08R\x0cpopulateNsid\x12+\n\x11\x65nrich_asn_enable\x18\xef\x01 \x01(\x08R\x0f\x65nrichAsnEnable\x12)\n\x0b\x61sn_db_path\x18\xf0\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n\x14\x61sn_refresh_interval\x18\xf1\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x12\x61snRefreshInterval\x12\x35\n\x16\x65nrich_locality_enable\x18\xf2\x01 \x01(\x08R\x14\x65nrichLocalityEnable\x12V\n\x19locality_refresh_interval\x18\xf3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x17localityRefreshInterval:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -228,11 +228,11 @@ _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_start=1846 _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_end=1924 _globals['_XTCPCONFIG']._serialized_start=1927 - _globals['_XTCPCONFIG']._serialized_end=5926 - _globals['_ENABLEDDESERIALIZERS']._serialized_start=5929 - _globals['_ENABLEDDESERIALIZERS']._serialized_end=6088 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=6030 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=6088 - _globals['_CONFIGSERVICE']._serialized_start=6091 - _globals['_CONFIGSERVICE']._serialized_end=6994 + _globals['_XTCPCONFIG']._serialized_end=6069 + _globals['_ENABLEDDESERIALIZERS']._serialized_start=6072 + _globals['_ENABLEDDESERIALIZERS']._serialized_end=6231 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=6173 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=6231 + _globals['_CONFIGSERVICE']._serialized_start=6234 + _globals['_CONFIGSERVICE']._serialized_end=7137 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi index a5ab2a6..721aacf 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi @@ -100,7 +100,7 @@ class SetEnvelopeFlushResponse(_message.Message): def __init__(self, config: _Optional[_Union[XtcpConfig, _Mapping]] = ...) -> None: ... class XtcpConfig(_message.Message): - __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "write_files", "capture_path", "modulus", "marshal_to", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "kafka_compression", "s3_endpoint", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_parquet_flush_threshold_bytes", "s3_region", "s3_skip_bucket_probe", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "dest", "dest_write_files", "topic", "xtcp_proto_file", "kafka_schema_url", "kafka_produce_timeout", "debug_level", "label", "tag", "location", "hostname", "daemon_version", "resolve_container_id", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "csv_columns", "poll_jitter_pct", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "reconcile_frequency", "reconcile_before_poll", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid", "enrich_asn_enable", "asn_db_path", "asn_refresh_interval") + __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "write_files", "capture_path", "modulus", "marshal_to", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "kafka_compression", "s3_endpoint", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_parquet_flush_threshold_bytes", "s3_region", "s3_skip_bucket_probe", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "dest", "dest_write_files", "topic", "xtcp_proto_file", "kafka_schema_url", "kafka_produce_timeout", "debug_level", "label", "tag", "location", "hostname", "daemon_version", "resolve_container_id", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "csv_columns", "poll_jitter_pct", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "reconcile_frequency", "reconcile_before_poll", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid", "enrich_asn_enable", "asn_db_path", "asn_refresh_interval", "enrich_locality_enable", "locality_refresh_interval") NL_TIMEOUT_MILLISECONDS_FIELD_NUMBER: _ClassVar[int] POLL_FREQUENCY_FIELD_NUMBER: _ClassVar[int] POLL_TIMEOUT_FIELD_NUMBER: _ClassVar[int] @@ -170,6 +170,8 @@ class XtcpConfig(_message.Message): ENRICH_ASN_ENABLE_FIELD_NUMBER: _ClassVar[int] ASN_DB_PATH_FIELD_NUMBER: _ClassVar[int] ASN_REFRESH_INTERVAL_FIELD_NUMBER: _ClassVar[int] + ENRICH_LOCALITY_ENABLE_FIELD_NUMBER: _ClassVar[int] + LOCALITY_REFRESH_INTERVAL_FIELD_NUMBER: _ClassVar[int] nl_timeout_milliseconds: int poll_frequency: _duration_pb2.Duration poll_timeout: _duration_pb2.Duration @@ -239,7 +241,9 @@ class XtcpConfig(_message.Message): enrich_asn_enable: bool asn_db_path: str asn_refresh_interval: _duration_pb2.Duration - def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., modulus: _Optional[int] = ..., marshal_to: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_region: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., dest: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., topic: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., debug_level: _Optional[int] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., location: _Optional[str] = ..., hostname: _Optional[str] = ..., daemon_version: _Optional[str] = ..., resolve_container_id: _Optional[bool] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., csv_columns: _Optional[str] = ..., poll_jitter_pct: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ..., enrich_asn_enable: _Optional[bool] = ..., asn_db_path: _Optional[str] = ..., asn_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ... + enrich_locality_enable: bool + locality_refresh_interval: _duration_pb2.Duration + def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., modulus: _Optional[int] = ..., marshal_to: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_region: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., dest: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., topic: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., debug_level: _Optional[int] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., location: _Optional[str] = ..., hostname: _Optional[str] = ..., daemon_version: _Optional[str] = ..., resolve_container_id: _Optional[bool] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., csv_columns: _Optional[str] = ..., poll_jitter_pct: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ..., enrich_asn_enable: _Optional[bool] = ..., asn_db_path: _Optional[str] = ..., asn_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., enrich_locality_enable: _Optional[bool] = ..., locality_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ... class EnabledDeserializers(_message.Message): __slots__ = ("enabled",) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py index 6d57b59..ea798c8 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xe3<\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n\x1dinet_diag_msg_socket_dest_asn\x18\xf3\x07 \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n!inet_diag_msg_socket_next_hop_asn\x18\xf4\x07 \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12S\n\'inet_diag_msg_socket_dest_network_owner\x18\xfa\x07 \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x46\n tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12(\n\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x35\n\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n\x1b\x63ongestion_algorithm_string\x18\x94\n \x01(\tR\x19\x63ongestionAlgorithmString\x12t\n\x19\x63ongestion_algorithm_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17\x63ongestionAlgorithmEnum\x12\'\n\x0ftype_of_service\x18\xf9\n \x01(\rR\rtypeOfService\x12$\n\rtraffic_class\x18\xfa\n \x01(\rR\x0ctrafficClass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12-\n\x13sk_mem_info_rcv_buf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvBuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12-\n\x13sk_mem_info_snd_buf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndBuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12&\n\x0eshutdown_state\x18\xc0\x0c \x01(\rR\rshutdownState\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12,\n\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12\x1a\n\x08\x63lass_id\x18\xd1\x0f \x01(\rR\x07\x63lassId\x12\x1a\n\x08sock_opt\x18\xd2\x0f \x01(\rR\x07sockOpt\x12\x18\n\x07\x63_group\x18\xb7\x10 \x01(\x04R\x06\x63Group\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc6>\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n\x1dinet_diag_msg_socket_dest_asn\x18\xf3\x07 \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n!inet_diag_msg_socket_next_hop_asn\x18\xf4\x07 \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12S\n\'inet_diag_msg_socket_dest_network_owner\x18\xfa\x07 \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12x\n\"inet_diag_msg_socket_dest_locality\x18\xfb\x07 \x01(\x0e\x32,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x1dinetDiagMsgSocketDestLocality\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x46\n tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12(\n\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x35\n\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n\x1b\x63ongestion_algorithm_string\x18\x94\n \x01(\tR\x19\x63ongestionAlgorithmString\x12t\n\x19\x63ongestion_algorithm_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17\x63ongestionAlgorithmEnum\x12\'\n\x0ftype_of_service\x18\xf9\n \x01(\rR\rtypeOfService\x12$\n\rtraffic_class\x18\xfa\n \x01(\rR\x0ctrafficClass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12-\n\x13sk_mem_info_rcv_buf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvBuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12-\n\x13sk_mem_info_snd_buf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndBuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12&\n\x0eshutdown_state\x18\xc0\x0c \x01(\rR\rshutdownState\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12,\n\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12\x1a\n\x08\x63lass_id\x18\xd1\x0f \x01(\rR\x07\x63lassId\x12\x1a\n\x08sock_opt\x18\xd2\x0f \x01(\rR\x07sockOpt\x12\x18\n\x07\x63_group\x18\xb7\x10 \x01(\x04R\x06\x63Group\"g\n\x08Locality\x12\x18\n\x14LOCALITY_UNSPECIFIED\x10\x00\x12\x11\n\rLOCALITY_SELF\x10\x01\x12\x19\n\x15LOCALITY_LOCAL_SUBNET\x10\x02\x12\x13\n\x0fLOCALITY_REMOTE\x10\x03\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -35,17 +35,19 @@ _globals['_ENVELOPE']._serialized_start=67 _globals['_ENVELOPE']._serialized_end=132 _globals['_XTCPFLATRECORD']._serialized_start=135 - _globals['_XTCPFLATRECORD']._serialized_end=7914 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=7633 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=7914 - _globals['_FLATRECORDSREQUEST']._serialized_start=7916 - _globals['_FLATRECORDSREQUEST']._serialized_end=7936 - _globals['_FLATRECORDSRESPONSE']._serialized_start=7938 - _globals['_FLATRECORDSRESPONSE']._serialized_end=8038 - _globals['_POLLFLATRECORDSREQUEST']._serialized_start=8040 - _globals['_POLLFLATRECORDSREQUEST']._serialized_end=8064 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=8066 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=8170 - _globals['_XTCPFLATRECORDSERVICE']._serialized_start=8173 - _globals['_XTCPFLATRECORDSERVICE']._serialized_end=8410 + _globals['_XTCPFLATRECORD']._serialized_end=8141 + _globals['_XTCPFLATRECORD_LOCALITY']._serialized_start=7754 + _globals['_XTCPFLATRECORD_LOCALITY']._serialized_end=7857 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=7860 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=8141 + _globals['_FLATRECORDSREQUEST']._serialized_start=8143 + _globals['_FLATRECORDSREQUEST']._serialized_end=8163 + _globals['_FLATRECORDSRESPONSE']._serialized_start=8165 + _globals['_FLATRECORDSRESPONSE']._serialized_end=8265 + _globals['_POLLFLATRECORDSREQUEST']._serialized_start=8267 + _globals['_POLLFLATRECORDSREQUEST']._serialized_end=8291 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=8293 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=8397 + _globals['_XTCPFLATRECORDSERVICE']._serialized_start=8400 + _globals['_XTCPFLATRECORDSERVICE']._serialized_end=8637 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi index 56fa6c2..683ab76 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi @@ -14,7 +14,17 @@ class Envelope(_message.Message): def __init__(self, row: _Optional[_Iterable[_Union[XtcpFlatRecord, _Mapping]]] = ...) -> None: ... class XtcpFlatRecord(_message.Message): - __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "inet_diag_msg_socket_dest_network_owner", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_delivery_rate_app_limited", "tcp_info_fast_open_client_failed", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rtt_var", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_adv_mss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_not_sent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "congestion_algorithm_string", "congestion_algorithm_enum", "type_of_service", "traffic_class", "sk_mem_info_rmem_alloc", "sk_mem_info_rcv_buf", "sk_mem_info_wmem_alloc", "sk_mem_info_snd_buf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "shutdown_state", "vegas_info_enabled", "vegas_info_rtt_cnt", "vegas_info_rtt", "vegas_info_min_rtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "class_id", "sock_opt", "c_group") + __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "inet_diag_msg_socket_dest_network_owner", "inet_diag_msg_socket_dest_locality", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_delivery_rate_app_limited", "tcp_info_fast_open_client_failed", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rtt_var", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_adv_mss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_not_sent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "congestion_algorithm_string", "congestion_algorithm_enum", "type_of_service", "traffic_class", "sk_mem_info_rmem_alloc", "sk_mem_info_rcv_buf", "sk_mem_info_wmem_alloc", "sk_mem_info_snd_buf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "shutdown_state", "vegas_info_enabled", "vegas_info_rtt_cnt", "vegas_info_rtt", "vegas_info_min_rtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "class_id", "sock_opt", "c_group") + class Locality(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + LOCALITY_UNSPECIFIED: _ClassVar[XtcpFlatRecord.Locality] + LOCALITY_SELF: _ClassVar[XtcpFlatRecord.Locality] + LOCALITY_LOCAL_SUBNET: _ClassVar[XtcpFlatRecord.Locality] + LOCALITY_REMOTE: _ClassVar[XtcpFlatRecord.Locality] + LOCALITY_UNSPECIFIED: XtcpFlatRecord.Locality + LOCALITY_SELF: XtcpFlatRecord.Locality + LOCALITY_LOCAL_SUBNET: XtcpFlatRecord.Locality + LOCALITY_REMOTE: XtcpFlatRecord.Locality class CongestionAlgorithm(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CONGESTION_ALGORITHM_UNSPECIFIED: _ClassVar[XtcpFlatRecord.CongestionAlgorithm] @@ -94,6 +104,7 @@ class XtcpFlatRecord(_message.Message): INET_DIAG_MSG_UID_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_INODE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_SOCKET_DEST_NETWORK_OWNER_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_MSG_SOCKET_DEST_LOCALITY_FIELD_NUMBER: _ClassVar[int] MEM_INFO_RMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_WMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_FMEM_FIELD_NUMBER: _ClassVar[int] @@ -251,6 +262,7 @@ class XtcpFlatRecord(_message.Message): inet_diag_msg_uid: int inet_diag_msg_inode: int inet_diag_msg_socket_dest_network_owner: str + inet_diag_msg_socket_dest_locality: XtcpFlatRecord.Locality mem_info_rmem: int mem_info_wmem: int mem_info_fmem: int @@ -347,7 +359,7 @@ class XtcpFlatRecord(_message.Message): class_id: int sock_opt: int c_group: int - def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_socket_dest_asn: _Optional[int] = ..., inet_diag_msg_socket_next_hop_asn: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., inet_diag_msg_socket_dest_network_owner: _Optional[str] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_send_scale: _Optional[int] = ..., tcp_info_rcv_scale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fast_open_client_failed: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rtt_var: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_adv_mss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_not_sent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., congestion_algorithm_string: _Optional[str] = ..., congestion_algorithm_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., type_of_service: _Optional[int] = ..., traffic_class: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcv_buf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_snd_buf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., shutdown_state: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rtt_cnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_min_rtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., class_id: _Optional[int] = ..., sock_opt: _Optional[int] = ..., c_group: _Optional[int] = ...) -> None: ... + def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_socket_dest_asn: _Optional[int] = ..., inet_diag_msg_socket_next_hop_asn: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., inet_diag_msg_socket_dest_network_owner: _Optional[str] = ..., inet_diag_msg_socket_dest_locality: _Optional[_Union[XtcpFlatRecord.Locality, str]] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_send_scale: _Optional[int] = ..., tcp_info_rcv_scale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fast_open_client_failed: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rtt_var: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_adv_mss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_not_sent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., congestion_algorithm_string: _Optional[str] = ..., congestion_algorithm_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., type_of_service: _Optional[int] = ..., traffic_class: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcv_buf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_snd_buf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., shutdown_state: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rtt_cnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_min_rtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., class_id: _Optional[int] = ..., sock_opt: _Optional[int] = ..., c_group: _Optional[int] = ...) -> None: ... class FlatRecordsRequest(_message.Message): __slots__ = () diff --git a/nix/capture-netlink-fixtures.nix b/nix/capture-netlink-fixtures.nix new file mode 100644 index 0000000..cd59726 --- /dev/null +++ b/nix/capture-netlink-fixtures.nix @@ -0,0 +1,129 @@ +# nix/capture-netlink-fixtures.nix +# +# Reproducible capture of REAL rtnetlink DUMP replies for the pkg/xtcpnl +# testdata harness, using the kernel's `nlmon` monitor interface. This is +# the source step behind the RTM_GETLINK / RTM_GETADDR / RTM_GETROUTE +# fixtures that pkg/xtcpnl and pkg/localnet parse; keeping it in-tree means +# the fixtures can be regenerated later on any kernel to the same standard +# as the existing sock_diag captures (testdata//…). +# +# Usage (run from the xtcp2 repo root): +# nix run .#capture-netlink-fixtures +# nix run .#capture-netlink-fixtures -- +# +# It loads `nlmon`, creates a temporary `nlmon0`, and captures three tight +# per-type dumps. `nlmon` mirrors EVERY netlink datagram in the namespace, +# so the raw capture also contains unrelated NETLINK_GENERIC traffic +# (nl80211, etc.). Each capture is therefore filtered to NETLINK_ROUTE +# only via the BPF expression `ether[14:2]==0` — the netlink family lives +# at offset 14-15 of the 16-byte Linux-SLL cooked header, and +# NETLINK_ROUTE == 0 (cf. the committed testdata/*/netlink_cooked_header, +# whose sock_diag capture ends in 0x0004 == NETLINK_SOCK_DIAG). +# +# Privileged steps (modprobe / ip link / tcpdump) go through `sudo`, so the +# script itself runs unprivileged under `nix run`; outputs are chowned back +# to the invoking user at the end. The version dir is derived from +# `uname -r` (e.g. 7.1.8 -> testdata/7_1_8), matching the harness naming. +# +{ pkgs }: + +pkgs.writeShellApplication { + name = "xtcp2-capture-netlink-fixtures"; + runtimeInputs = with pkgs; [ + coreutils + gnugrep + iproute2 + tcpdump + kmod + ]; + text = '' + set -euo pipefail + + # `sudo` is the NixOS setuid wrapper, not a runtimeInput; make it + # resolvable while still preferring our pinned tools for everything else. + export PATH="/run/wrappers/bin:$PATH" + + if [ ! -f flake.nix ] || [ ! -d pkg/xtcpnl ]; then + echo "capture-netlink-fixtures: run from the xtcp2 repo root" >&2 + exit 2 + fi + + # Derive the testdata version dir from the running kernel: 7.1.8 -> 7_1_8. + VER="$(uname -r | cut -d- -f1 | tr . _)" + OUT="''${1:-pkg/xtcpnl/testdata/$VER}" + IFACE="nlmon0" + WARMUP=1 # seconds to let tcpdump bind before triggering the dump + + # Absolute nix-store paths so `sudo` (which resets PATH to secure_path) + # still runs our pinned binaries. modprobe is left bare so sudo's + # secure_path picks the system wrapper that knows the NixOS module dir. + IP="$(command -v ip)" + TCPDUMP="$(command -v tcpdump)" + CHOWN="$(command -v chown)" + RM="$(command -v rm)" + + USER_NAME="$(id -un)" + GROUP_NAME="$(id -gn)" + + mkdir -p "$OUT" + + echo "== loading nlmon ==" + sudo modprobe nlmon + # Read lsmod via a here-string, not a pipe: `grep -q` closes the pipe on + # first match and lsmod's (large) output then dies with SIGPIPE, which + # `set -o pipefail` would report as a failure. + grep -qw nlmon <<<"$(lsmod)" || { echo "nlmon failed to load" >&2; exit 1; } + + echo "== (re)creating $IFACE ==" + sudo "$IP" link del "$IFACE" 2>/dev/null || true + sudo "$IP" link add "$IFACE" type nlmon + sudo "$IP" link set dev "$IFACE" up + + cleanup() { sudo "$IP" link del "$IFACE" 2>/dev/null || true; } + trap cleanup EXIT + + # Capture one dump type into a raw pcap, then filter to NETLINK_ROUTE. + # The generator (RTM_GET*) command runs unprivileged and opens a + # NETLINK_ROUTE socket that nlmon mirrors; a SIGINT to tcpdump after + # the dump completes stops it cleanly so the pcap is flushed. + cap() { + name="$1"; shift + raw="$OUT/.$name.raw.pcap" + echo "== capturing $name ==" + sudo "$TCPDUMP" -i "$IFACE" -w "$raw" -U -q >/dev/null 2>&1 & + tp=$! + sleep "$WARMUP" + "$@" >/dev/null 2>&1 || true + sleep 1 + sudo kill -INT "$tp" 2>/dev/null || true + wait "$tp" 2>/dev/null || true + sudo "$TCPDUMP" -r "$raw" -w "$OUT/$name.pcap" 'ether[14:2]==0' >/dev/null 2>&1 + sudo "$RM" -f "$raw" + n="$(sudo "$TCPDUMP" -nnq -r "$OUT/$name.pcap" 2>/dev/null | grep -cE '^[0-9]{2}:' || true)" + echo " -> $OUT/$name.pcap ($n NETLINK_ROUTE packets)" + } + + gen_addr() { "$IP" -4 addr show; "$IP" -6 addr show; } + gen_route() { "$IP" route show table all; } + gen_link() { "$IP" link show; } + + cap netlink_route_getaddr gen_addr + cap netlink_route_getroute gen_route + cap netlink_route_getlink gen_link + + # Write sidecars via `sudo tee`: the pcaps were captured by sudo'd + # tcpdump (root-owned), so $OUT may be root-owned until the final chown; + # tee-as-root sidesteps a permission error on the plain `>` redirect. + echo "== source-of-truth sidecars ==" + uname -a | sudo tee "$OUT/uname" >/dev/null + "$IP" -d addr show | sudo tee "$OUT/ip_addr_n" >/dev/null + "$IP" -d route show table all | sudo tee "$OUT/ip_route_table_all_n" >/dev/null + "$IP" -d link show | sudo tee "$OUT/ip_link_n" >/dev/null + + echo "== chown $OUT -> $USER_NAME:$GROUP_NAME ==" + sudo "$CHOWN" -R "$USER_NAME:$GROUP_NAME" "$OUT" + + echo "== done ==" + ls -la "$OUT" + ''; +} diff --git a/nix/default.nix b/nix/default.nix index 3b872bc..3695f12 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -123,6 +123,12 @@ let # against the user's GOMODCACHE. coverageMerge = import ./coverage-merge.nix { inherit pkgs; }; + # Reproducible nlmon-based capture of real rtnetlink DUMP replies for the + # pkg/xtcpnl testdata harness. Invoked via + # `nix run .#capture-netlink-fixtures` from the repo root; see the file + # header for the filtering/versioning rationale. + captureNetlinkFixtures = import ./capture-netlink-fixtures.nix { inherit pkgs; }; + lintFixOne = pkgs.writeShellApplication { name = "xtcp2-lint-fix-one"; runtimeInputs = [ versions.golangci-lint ]; @@ -593,6 +599,10 @@ in type = "app"; program = "${protos.regenerate}/bin/regen-protos"; }; + capture-netlink-fixtures = { + type = "app"; + program = "${captureNetlinkFixtures}/bin/xtcp2-capture-netlink-fixtures"; + }; # Run the whole microVM integration suite sequentially. Lifecycle sweep # by default; `-- --soak [--duration 1h]` adds the duration runners. integration-all = { diff --git a/pkg/localnet/localnet.go b/pkg/localnet/localnet.go new file mode 100644 index 0000000..03f13d8 --- /dev/null +++ b/pkg/localnet/localnet.go @@ -0,0 +1,169 @@ +// Package localnet classifies a socket endpoint IP as belonging to the local +// host (self), a directly-connected subnet, or somewhere remote, using the +// local addresses and routing table of a specific network namespace. +// +// It is the consumer side of the rtnetlink discovery machinery in pkg/xtcpnl: +// xtcp2 dumps each monitored namespace's RTM_GETADDR + RTM_GETROUTE (and +// RTM_GETLINK) replies, feeds the parsed AddrInfo/RouteInfo into BuildSnapshot, +// and publishes the immutable Snapshot atomically. On xtcp2's per-socket +// enrichment hot path a destination address is classified with Classify before +// the internet IP->ASN lookup: self and connected-subnet destinations never +// reach the ASN feed. +// +// A Snapshot is built once (off the hot path) and never mutated; Classify is a +// pure, allocation-free, lock-free read, mirroring pkg/ipasn's contract. +package localnet + +import ( + "net/netip" + + "github.com/gaissmai/bart" + "golang.org/x/sys/unix" + + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// Locality is how a socket endpoint relates to a namespace's local network. The +// values match the xtcp_flat_record Locality enum so a Locality can be stored +// directly as the record field. +type Locality uint8 + +const ( + // LocalityUnspecified means the endpoint could not be classified (e.g. an + // unparseable address, or no snapshot yet). + LocalityUnspecified Locality = 0 + // LocalitySelf means the endpoint is one of this namespace's own addresses + // (or loopback) — traffic that terminates on this host. + LocalitySelf Locality = 1 + // LocalitySubnet means the endpoint is on a directly-connected subnet (a + // scope-link route with no gateway) — one L2 hop away, no routing. + LocalitySubnet Locality = 2 + // LocalityRemote means the endpoint is reached via a gateway — the only + // class that should fall through to the IP->ASN lookup. + LocalityRemote Locality = 3 +) + +// String renders the Locality for logs/columns. +func (l Locality) String() string { + switch l { + case LocalitySelf: + return "self" + case LocalitySubnet: + return "connected_subnet" + case LocalityRemote: + return "remote" + default: + return "unspecified" + } +} + +// Snapshot is an immutable per-namespace view of local addresses and connected +// subnets. Self addresses are stored as host prefixes (/32, /128) and connected +// subnets as their network prefix in a single longest-prefix-match trie, so a +// self host address wins over its containing subnet in one Lookup. The zero +// value classifies everything as remote; build with BuildSnapshot. +type Snapshot struct { + tbl *bart.Table[Locality] +} + +// Classify returns how addr relates to this snapshot's namespace. Loopback and +// the unspecified address short-circuit to self; a valid non-self address that +// matches a connected subnet is LocalitySubnet; anything else is LocalityRemote. +// An invalid address is LocalityUnspecified. Pure and allocation-free. +func (s *Snapshot) Classify(addr netip.Addr) Locality { + a := addr.Unmap() + if !a.IsValid() { + return LocalityUnspecified + } + if a.IsLoopback() || a.IsUnspecified() { + return LocalitySelf + } + if s == nil || s.tbl == nil { + return LocalityRemote + } + if v, ok := s.tbl.Lookup(a); ok { + return v + } + return LocalityRemote +} + +// BuildSnapshot constructs a Snapshot from one namespace's parsed RTM_GETADDR +// and RTM_GETROUTE replies. Self set = every interface address (IFA_LOCAL, +// falling back to IFA_ADDRESS) plus every RTN_LOCAL route destination. +// Connected subnets = routes that are unicast, gatewayless and carry a +// destination prefix (scope is NOT part of the test — IPv4 connected subnets +// are scope-link but IPv6 connected subnets are scope-universe). It is pure: +// no syscalls, safe to feed test fixtures. +func BuildSnapshot(addrs []xtcpnl.AddrInfo, routes []xtcpnl.RouteInfo) *Snapshot { + tbl := new(bart.Table[Locality]) + + for _, ai := range addrs { + raw := ai.Local + if len(raw) == 0 { + raw = ai.Address + } + if a, ok := addrFromBytes(raw); ok { + tbl.Insert(hostPrefix(a), LocalitySelf) + } + } + + for _, ri := range routes { + switch { + case ri.Type == unix.RTN_LOCAL: + // A locally-attached address (usually in RT_TABLE_LOCAL, scope host). + if a, ok := addrFromBytes(ri.Dst); ok { + tbl.Insert(hostPrefix(a), LocalitySelf) + } + case ri.Type == unix.RTN_UNICAST && + len(ri.Gateway) == 0 && + len(ri.Dst) > 0: + // A directly-connected subnet (one L2 hop, no next-hop router). + // The distinguishing signal is unicast + a destination prefix + no + // gateway, NOT the route scope: real captures show IPv4 connected + // subnets carry scope=RT_SCOPE_LINK (253) while IPv6 connected + // subnets carry scope=RT_SCOPE_UNIVERSE (0), so gating on + // RT_SCOPE_LINK silently misclassifies every IPv6 on-link subnet as + // REMOTE. + if pfx, ok := prefixFromBytes(ri.Dst, ri.DstLen); ok { + // Don't let a /0 connected route swallow everything into + // LocalitySubnet. + if pfx.Bits() > 0 { + tbl.Insert(pfx, LocalitySubnet) + } + } + } + } + + return &Snapshot{tbl: tbl} +} + +// addrFromBytes converts raw network-order address bytes (4 = IPv4, 16 = IPv6) +// to an unmapped netip.Addr. Any other length is rejected. +func addrFromBytes(b []byte) (netip.Addr, bool) { + if len(b) != 4 && len(b) != 16 { + return netip.Addr{}, false + } + a, ok := netip.AddrFromSlice(b) + if !ok { + return netip.Addr{}, false + } + return a.Unmap(), true +} + +// hostPrefix returns the /32 or /128 single-host prefix for a. +func hostPrefix(a netip.Addr) netip.Prefix { + return netip.PrefixFrom(a, a.BitLen()) +} + +// prefixFromBytes builds a canonical (masked) prefix from raw destination bytes +// and a prefix length, rejecting a length that exceeds the address width. +func prefixFromBytes(b []byte, bits uint8) (netip.Prefix, bool) { + a, ok := addrFromBytes(b) + if !ok { + return netip.Prefix{}, false + } + if int(bits) > a.BitLen() { + return netip.Prefix{}, false + } + return netip.PrefixFrom(a, int(bits)).Masked(), true +} diff --git a/pkg/localnet/localnet_race_test.go b/pkg/localnet/localnet_race_test.go new file mode 100644 index 0000000..339e021 --- /dev/null +++ b/pkg/localnet/localnet_race_test.go @@ -0,0 +1,108 @@ +package localnet + +import ( + "net/netip" + "sync" + "sync/atomic" + "testing" + + "golang.org/x/sys/unix" + + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// TestClassifyConcurrentWithStore exercises the production hot-path contract: +// many goroutines call Classify on the currently-published snapshot while a +// writer atomically swaps in freshly-built snapshots (the refresh path). Run +// under -race to prove Classify is a safe lock-free reader and BuildSnapshot's +// output is never mutated after publication. +// +// go test ./pkg/localnet/ -race -run TestClassifyConcurrentWithStore +func TestClassifyConcurrentWithStore(t *testing.T) { + mk := func(third byte) *Snapshot { + return BuildSnapshot( + []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: []byte{10, 0, third, 5}}}, + []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, []byte{10, 0, third, 0}, 24)}, + ) + } + + var cur atomic.Pointer[Snapshot] + cur.Store(mk(0)) + + const readers = 8 + const iters = 20000 + + // Writer runs until the readers finish (stop closed), continuously swapping + // the published snapshot. + stop := make(chan struct{}) + var writer sync.WaitGroup + writer.Add(1) + go func() { + defer writer.Done() + var i byte + for { + select { + case <-stop: + return + default: + cur.Store(mk(i)) + i++ + } + } + }() + + // Readers: classify a mix of self / subnet / remote addresses, each for a + // bounded number of iterations. + probes := []netip.Addr{ + netip.MustParseAddr("10.0.0.5"), + netip.MustParseAddr("10.0.0.42"), + netip.MustParseAddr("8.8.8.8"), + netip.MustParseAddr("127.0.0.1"), + } + var rwg sync.WaitGroup + for r := 0; r < readers; r++ { + rwg.Add(1) + go func() { + defer rwg.Done() + for i := 0; i < iters; i++ { + snap := cur.Load() + _ = snap.Classify(probes[i%len(probes)]) + } + }() + } + + rwg.Wait() // readers done + close(stop) // then wind down the writer + writer.Wait() +} + +var benchSink Locality + +// BenchmarkClassify measures the hot-path Classify cost for the three outcomes. +// +// go test ./pkg/localnet/ -bench BenchmarkClassify -run x +func BenchmarkClassify(b *testing.B) { + snap := BuildSnapshot( + []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: []byte{10, 0, 0, 5}}}, + []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, []byte{10, 0, 0, 0}, 24)}, + ) + + cases := []struct { + name string + addr netip.Addr + }{ + {"self", netip.MustParseAddr("10.0.0.5")}, + {"subnet", netip.MustParseAddr("10.0.0.42")}, + {"remote", netip.MustParseAddr("8.8.8.8")}, + } + for _, c := range cases { + b.Run(c.name, func(b *testing.B) { + b.ReportAllocs() + var out Locality + for i := 0; i < b.N; i++ { + out = snap.Classify(c.addr) + } + benchSink = out + }) + } +} diff --git a/pkg/localnet/localnet_realfixtures_test.go b/pkg/localnet/localnet_realfixtures_test.go new file mode 100644 index 0000000..a13d772 --- /dev/null +++ b/pkg/localnet/localnet_realfixtures_test.go @@ -0,0 +1,152 @@ +package localnet + +import ( + "net/netip" + "os" + "testing" + + "golang.org/x/sys/unix" + + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// This test drives the full feature end-to-end on REAL kernel bytes: it reads +// the same nlmon-captured 7.1.8 dump fixtures the xtcpnl parser tests use +// (pkg/xtcpnl/testdata/7_1_8, produced by nix run .#capture-netlink-fixtures), +// parses the RTM_NEWADDR + RTM_NEWROUTE messages with xtcpnl.ParseNewAddr / +// ParseNewRoute, feeds them to BuildSnapshot, and asserts Classify against the +// real addresses/subnets transcribed from that host's ip_addr_n / +// ip_route_table_all_n. It is the guard that the real wire format actually +// classifies the way the synthetic TestClassify assumes — in particular that +// IPv6 connected subnets (scope UNIVERSE, not LINK) resolve to LocalitySubnet. +// +// Fixtures live in the xtcpnl package; reference them by relative path. +const fixtureDir = "../xtcpnl/testdata/7_1_8" + +// walkRealDump walks a committed *_dump.pcap the same way xtcpnl.DumpRtnetlink +// does at runtime — from PcapNetlinkOffsetCst, 4-byte-aligned nlmsghdr steps, +// stopping at NLMSG_DONE — invoking fn with each RTM_NEW* body. It reuses only +// xtcpnl's exported wire primitives so localnet has no dependency on xtcpnl test +// internals. +func walkRealDump(t *testing.T, name string, fn func(mtype uint16, body []byte)) { + t.Helper() + bs, err := os.ReadFile(fixtureDir + "/" + name) + if err != nil { + t.Fatalf("ReadFile(%s): %v", name, err) + } + if len(bs) < xtcpnl.PcapNetlinkOffsetCst { + t.Fatalf("%s: fixture too small (%d bytes)", name, len(bs)) + } + data := bs[xtcpnl.PcapNetlinkOffsetCst:] + sawDone := false + for len(data) >= xtcpnl.NlMsgHdrSizeCst { + var h xtcpnl.NlMsgHdr + if _, derr := xtcpnl.DeserializeNlMsgHdr(data, &h); derr != nil { + t.Fatalf("%s: DeserializeNlMsgHdr: %v", name, derr) + } + mlen := int(h.Len) + if mlen < xtcpnl.NlMsgHdrSizeCst || mlen > len(data) { + t.Fatalf("%s: bad nlmsg_len %d (remaining %d)", name, mlen, len(data)) + } + if h.Type == uint16(unix.NLMSG_DONE) { + sawDone = true + break + } + fn(h.Type, data[xtcpnl.NlMsgHdrSizeCst:mlen]) + adv := mlen + xtcpnl.FourByteAlignPadding(mlen) + if adv <= 0 || adv > len(data) { + break + } + data = data[adv:] + } + if !sawDone { + t.Fatalf("%s: dump not terminated by NLMSG_DONE", name) + } +} + +// buildRealSnapshot parses the v4+v6 address dumps and the route dump into a +// Snapshot the same way the runtime locality refresh will. +func buildRealSnapshot(t *testing.T) *Snapshot { + t.Helper() + var addrs []xtcpnl.AddrInfo + for _, f := range []string{"netlink_route_getaddr_v4_dump.pcap", "netlink_route_getaddr_v6_dump.pcap"} { + walkRealDump(t, f, func(mt uint16, body []byte) { + if mt != uint16(unix.RTM_NEWADDR) { + return + } + ai, err := xtcpnl.ParseNewAddr(body) + if err != nil { + t.Fatalf("%s: ParseNewAddr: %v", f, err) + } + addrs = append(addrs, ai) + }) + } + var routes []xtcpnl.RouteInfo + walkRealDump(t, "netlink_route_getroute_dump.pcap", func(mt uint16, body []byte) { + if mt != uint16(unix.RTM_NEWROUTE) { + return + } + ri, err := xtcpnl.ParseNewRoute(body) + if err != nil { + t.Fatalf("getroute: ParseNewRoute: %v", err) + } + routes = append(routes, ri) + }) + + if len(addrs) != 24 { // 9 v4 + 15 v6 + t.Fatalf("parsed %d addresses, want 24", len(addrs)) + } + if len(routes) != 74 { + t.Fatalf("parsed %d routes, want 74", len(routes)) + } + return BuildSnapshot(addrs, routes) +} + +// TestClassifyRealFixture classifies real destination addresses against a +// Snapshot built from this host's captured dumps. Every row cites the sidecar +// line the address/subnet came from. +// +// go test ./pkg/localnet/ -run TestClassifyRealFixture +func TestClassifyRealFixture(t *testing.T) { + snap := buildRealSnapshot(t) + + tests := []struct { + description string + addr string + want Locality + }{ + // positive — self (host's own addresses; RTN_LOCAL and/or IFA_LOCAL) + {"ip_addr_n:10 self v4 172.16.50.219 -> self", "172.16.50.219", LocalitySelf}, + {"ip_addr_n:23 self v4 10.10.4.2 -> self", "10.10.4.2", LocalitySelf}, + {"ip_addr_n:25 self v6 fd10:10:4::2 -> self", "fd10:10:4::2", LocalitySelf}, + {"ip_addr_n:16 self v6 2603:…:6adf:8a2f:21ae:d6a7 -> self", "2603:8002:ea00:6800:6adf:8a2f:21ae:d6a7", LocalitySelf}, + + // positive — connected subnet (peer inside an on-link prefix) + {"ip_route:2 peer in v4 connected 10.10.4.0/29 -> subnet", "10.10.4.5", LocalitySubnet}, + {"ip_route:6 peer in v4 connected 172.16.50.0/24 -> subnet", "172.16.50.100", LocalitySubnet}, + {"ip_route:29 peer in v6 connected fd10:10:4::/64 (scope UNIVERSE) -> subnet", "fd10:10:4::abcd", LocalitySubnet}, + {"ip_route:27 peer in v6 connected 2603:…:6800::/64 -> subnet", "2603:8002:ea00:6800::5", LocalitySubnet}, + + // negative — remote + {"public v4 not in any prefix -> remote", "8.8.8.8", LocalityRemote}, + {"public v6 not in any prefix -> remote", "2606:4700::1111", LocalityRemote}, + {"v4 just outside connected 10.10.4.0/29 (.8) -> remote", "10.10.4.8", LocalityRemote}, + + // boundary — self /32 & /128 win over the containing connected subnet + {"self /32 10.10.4.2 wins over 10.10.4.0/29 subnet", "10.10.4.2", LocalitySelf}, + {"self /128 fd10:10:4::2 wins over fd10:10:4::/64 subnet", "fd10:10:4::2", LocalitySelf}, + + // corner — loopback short-circuits regardless of snapshot contents + {"v4 loopback -> self", "127.0.0.1", LocalitySelf}, + {"v6 loopback -> self", "::1", LocalitySelf}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got := snap.Classify(netip.MustParseAddr(tc.addr)) + if got != tc.want { + t.Errorf("Classify(%s) = %v, want %v", tc.addr, got, tc.want) + } + }) + } +} diff --git a/pkg/localnet/localnet_test.go b/pkg/localnet/localnet_test.go new file mode 100644 index 0000000..a1f79df --- /dev/null +++ b/pkg/localnet/localnet_test.go @@ -0,0 +1,304 @@ +package localnet + +import ( + "net/netip" + "testing" + + "golang.org/x/sys/unix" + + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// v4 returns the 4-byte network-order form of an IPv4 dotted string. +func v4(t *testing.T, s string) []byte { + t.Helper() + a := netip.MustParseAddr(s) + if !a.Is4() { + t.Fatalf("v4: %q is not IPv4", s) + } + b := a.As4() + return b[:] +} + +// v6 returns the 16-byte network-order form of an IPv6 string. +func v6(t *testing.T, s string) []byte { + t.Helper() + a := netip.MustParseAddr(s) + if !a.Is6() { + t.Fatalf("v6: %q is not IPv6", s) + } + b := a.As16() + return b[:] +} + +// connectedRoute builds a directly-connected (scope-link, gatewayless, unicast) +// route to dst/bits. +func connectedRoute(family uint8, dst []byte, bits uint8) xtcpnl.RouteInfo { + return xtcpnl.RouteInfo{ + Family: family, + DstLen: bits, + Type: unix.RTN_UNICAST, + Scope: unix.RT_SCOPE_LINK, + Dst: dst, + } +} + +// gatewayRoute builds a route reached via a next-hop gateway (NOT connected). +func gatewayRoute(family uint8, dst []byte, bits uint8, gw []byte) xtcpnl.RouteInfo { + return xtcpnl.RouteInfo{ + Family: family, + DstLen: bits, + Type: unix.RTN_UNICAST, + Scope: unix.RT_SCOPE_UNIVERSE, + Dst: dst, + Gateway: gw, + } +} + +// localRoute builds an RTN_LOCAL route (a locally-attached host address). +func localRoute(family uint8, dst []byte) xtcpnl.RouteInfo { + return xtcpnl.RouteInfo{ + Family: family, + DstLen: uint8(len(dst) * 8), + Type: unix.RTN_LOCAL, + Scope: unix.RT_SCOPE_HOST, + Dst: dst, + } +} + +// TestClassify feeds a BuildSnapshot-produced Snapshot a range of destination +// addresses and asserts the classification. Every row carries a description and +// the expected Locality, covering positive, negative, boundary and corner cases. +// +// go test ./pkg/localnet/ -run TestClassify +func TestClassify(t *testing.T) { + // A representative dual-stack namespace: + // - self v4 10.0.0.5 (from IFA_LOCAL) self v6 2001:db8::5 + // - connected subnet 10.0.0.0/24 connected v6 2001:db8::/64 + // - a local-table host route 172.16.0.1 (RTN_LOCAL) + addrs := []xtcpnl.AddrInfo{ + {Family: unix.AF_INET, Prefixlen: 24, Local: v4(t, "10.0.0.5"), Address: v4(t, "10.0.0.5")}, + {Family: unix.AF_INET6, Prefixlen: 64, Address: v6(t, "2001:db8::5")}, + } + routes := []xtcpnl.RouteInfo{ + connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 24), + connectedRoute(unix.AF_INET6, v6(t, "2001:db8::"), 64), + gatewayRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0, v4(t, "10.0.0.1")), // default via gw — must not create a subnet + localRoute(unix.AF_INET, v4(t, "172.16.0.1")), + } + snap := BuildSnapshot(addrs, routes) + + tests := []struct { + description string + addr string + want Locality + }{ + // positive + {"self IPv4 address (IFA_LOCAL) -> self", "10.0.0.5", LocalitySelf}, + {"self IPv6 address -> self", "2001:db8::5", LocalitySelf}, + {"RTN_LOCAL host route dest -> self", "172.16.0.1", LocalitySelf}, + {"peer in connected IPv4 subnet -> connected_subnet", "10.0.0.42", LocalitySubnet}, + {"peer in connected IPv6 subnet -> connected_subnet", "2001:db8::1234", LocalitySubnet}, + // negative + {"public IPv4 not in any set -> remote", "8.8.8.8", LocalityRemote}, + {"public IPv6 not in any set -> remote", "2606:4700::1111", LocalityRemote}, + {"address only reachable via gateway -> remote", "93.184.216.34", LocalityRemote}, + {"IPv4 just outside connected /24 -> remote", "10.0.1.1", LocalityRemote}, + // boundary + {"network address of connected subnet -> connected_subnet", "10.0.0.0", LocalitySubnet}, + {"broadcast-ish last host of /24 -> connected_subnet", "10.0.0.255", LocalitySubnet}, + {"self host /32 wins over containing /24 subnet", "10.0.0.5", LocalitySelf}, + // corner + {"IPv4 loopback short-circuits -> self", "127.0.0.1", LocalitySelf}, + {"IPv6 loopback short-circuits -> self", "::1", LocalitySelf}, + {"IPv4 unspecified short-circuits -> self", "0.0.0.0", LocalitySelf}, + {"IPv6 unspecified short-circuits -> self", "::", LocalitySelf}, + {"IPv4-mapped IPv6 of a self address -> self", "::ffff:10.0.0.5", LocalitySelf}, + {"IPv4-mapped IPv6 of a subnet peer -> connected_subnet", "::ffff:10.0.0.9", LocalitySubnet}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got := snap.Classify(netip.MustParseAddr(tc.addr)) + if got != tc.want { + t.Errorf("Classify(%s) = %v, want %v", tc.addr, got, tc.want) + } + }) + } +} + +// TestClassifyInvalidAndNil covers the invalid-address and nil/empty-snapshot +// corner cases that can't be expressed as a parseable address string. +// +// go test ./pkg/localnet/ -run TestClassifyInvalidAndNil +func TestClassifyInvalidAndNil(t *testing.T) { + empty := BuildSnapshot(nil, nil) + + tests := []struct { + description string + snap *Snapshot + addr netip.Addr + want Locality + }{ + {"invalid zero address -> unspecified", empty, netip.Addr{}, LocalityUnspecified}, + {"nil snapshot, valid remote address -> remote", nil, netip.MustParseAddr("8.8.8.8"), LocalityRemote}, + {"nil snapshot, loopback still short-circuits -> self", nil, netip.MustParseAddr("127.0.0.1"), LocalitySelf}, + {"empty snapshot, valid address -> remote", empty, netip.MustParseAddr("10.0.0.5"), LocalityRemote}, + {"empty snapshot, invalid address -> unspecified", empty, netip.Addr{}, LocalityUnspecified}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got := tc.snap.Classify(tc.addr) + if got != tc.want { + t.Errorf("Classify = %v, want %v", got, tc.want) + } + }) + } +} + +// TestBuildSnapshot asserts which inputs create self host prefixes vs connected +// subnets vs nothing, by probing the resulting snapshot. Table columns: +// description, the addrs/routes input, a probe address, and the expected +// Locality (the observable outcome of the build). +// +// go test ./pkg/localnet/ -run TestBuildSnapshot +func TestBuildSnapshot(t *testing.T) { + tests := []struct { + description string + addrs []xtcpnl.AddrInfo + routes []xtcpnl.RouteInfo + probe string + want Locality + }{ + // positive + { + description: "IFA_LOCAL populates the self set", + addrs: []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: v4(t, "10.1.2.3")}}, + probe: "10.1.2.3", + want: LocalitySelf, + }, + { + description: "IFA_ADDRESS used when IFA_LOCAL absent", + addrs: []xtcpnl.AddrInfo{{Family: unix.AF_INET6, Address: v6(t, "fe80::1")}}, + probe: "fe80::1", + want: LocalitySelf, + }, + { + description: "scope-link gatewayless unicast route (IPv4 connected subnet) -> subnet", + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "192.168.0.0"), 24)}, + probe: "192.168.0.7", + want: LocalitySubnet, + }, + { + // Real kernels emit IPv6 connected subnets with scope + // RT_SCOPE_UNIVERSE (0), not RT_SCOPE_LINK — confirmed by the 7.1.8 + // getroute fixture (pkg/xtcpnl/testdata/7_1_8, fd10:10:4::/64). The + // connected-subnet rule must therefore be scope-agnostic: unicast + + // gatewayless + has-Dst. A scope-link gate would misclassify every + // IPv6 on-link subnet as remote. + description: "universe-scope gatewayless unicast route (IPv6 connected subnet) -> subnet", + routes: []xtcpnl.RouteInfo{{ + Family: unix.AF_INET6, DstLen: 64, Type: unix.RTN_UNICAST, + Scope: unix.RT_SCOPE_UNIVERSE, Dst: v6(t, "fd10:10:4::"), + }}, + probe: "fd10:10:4::7", + want: LocalitySubnet, + }, + // negative + { + description: "route with a gateway is NOT a connected subnet", + routes: []xtcpnl.RouteInfo{gatewayRoute(unix.AF_INET, v4(t, "192.168.0.0"), 24, v4(t, "192.168.0.1"))}, + probe: "192.168.0.7", + want: LocalityRemote, + }, + // boundary + { + description: "/32 connected route classifies only that host", + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "10.9.9.9"), 32)}, + probe: "10.9.9.9", + want: LocalitySubnet, + }, + { + description: "/32 connected route does not cover a neighbour", + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "10.9.9.9"), 32)}, + probe: "10.9.9.10", + want: LocalityRemote, + }, + { + description: "scope-link /0 route is dropped (must not swallow everything)", + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0)}, + probe: "8.8.8.8", + want: LocalityRemote, + }, + { + description: "more-specific connected subnet still classifies as subnet", + routes: []xtcpnl.RouteInfo{ + connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 8), + connectedRoute(unix.AF_INET, v4(t, "10.1.0.0"), 16), + }, + probe: "10.1.2.3", + want: LocalitySubnet, + }, + // corner + { + description: "zero-length Dst route skipped, address stays remote", + routes: []xtcpnl.RouteInfo{{Family: unix.AF_INET, DstLen: 24, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_LINK}}, + probe: "10.0.0.1", + want: LocalityRemote, + }, + { + description: "malformed 3-byte address is skipped", + addrs: []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: []byte{10, 0, 0}}}, + probe: "10.0.0.5", + want: LocalityRemote, + }, + { + description: "prefix length beyond address width is skipped", + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 40)}, + probe: "10.0.0.1", + want: LocalityRemote, + }, + { + description: "RTN_LOCAL route adds a self host address", + routes: []xtcpnl.RouteInfo{localRoute(unix.AF_INET6, v6(t, "2001:db8::99"))}, + probe: "2001:db8::99", + want: LocalitySelf, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + snap := BuildSnapshot(tc.addrs, tc.routes) + got := snap.Classify(netip.MustParseAddr(tc.probe)) + if got != tc.want { + t.Errorf("Classify(%s) = %v, want %v", tc.probe, got, tc.want) + } + }) + } +} + +// TestLocalityString checks the human-readable rendering used in logs/columns, +// including the out-of-range corner value. +// +// go test ./pkg/localnet/ -run TestLocalityString +func TestLocalityString(t *testing.T) { + tests := []struct { + description string + in Locality + want string + }{ + {"self", LocalitySelf, "self"}, + {"subnet", LocalitySubnet, "connected_subnet"}, + {"remote", LocalityRemote, "remote"}, + {"unspecified zero value", LocalityUnspecified, "unspecified"}, + {"out-of-range value falls back to unspecified", Locality(200), "unspecified"}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if got := tc.in.String(); got != tc.want { + t.Errorf("Locality(%d).String() = %q, want %q", tc.in, got, tc.want) + } + }) + } +} diff --git a/pkg/recordfmt/columns.go b/pkg/recordfmt/columns.go index 8ccb7f8..4e5c500 100644 --- a/pkg/recordfmt/columns.go +++ b/pkg/recordfmt/columns.go @@ -107,6 +107,8 @@ func formatField(r *xtcp_flat_record.XtcpFlatRecord, m protoreflect.Message, c C return TCPStateName(r.GetTcpInfoState()) case "congestionAlgorithmEnum": return CongestionAlgorithmName(r.GetCongestionAlgorithmEnum()) + case "inetDiagMsgSocketDestLocality": + return LocalityName(r.GetInetDiagMsgSocketDestLocality()) case "timestampNs": return TimestampRFC3339(r.GetTimestampNs()) } diff --git a/pkg/recordfmt/humanize.go b/pkg/recordfmt/humanize.go index 52c260a..89ccb2a 100644 --- a/pkg/recordfmt/humanize.go +++ b/pkg/recordfmt/humanize.go @@ -80,6 +80,16 @@ func CongestionAlgorithmName(e xtcp_flat_record.XtcpFlatRecord_CongestionAlgorit return strings.TrimPrefix(e.String(), "CONGESTION_ALGORITHM_") } +// LocalityName returns the short destination-locality name (e.g. "SELF", +// "LOCAL_SUBNET", "REMOTE") by trimming the generated enum's LOCALITY_ prefix. +// UNSPECIFIED renders as "". +func LocalityName(l xtcp_flat_record.XtcpFlatRecord_Locality) string { + if l == xtcp_flat_record.XtcpFlatRecord_LOCALITY_UNSPECIFIED { + return "" + } + return strings.TrimPrefix(l.String(), "LOCALITY_") +} + // TimestampRFC3339 formats a record's timestamp_ns (int64 Unix nanoseconds) as // RFC3339 with nanosecond precision in UTC. Zero → "". func TimestampRFC3339(ns int64) string { diff --git a/pkg/xtcp/destinations_s3parquet.go b/pkg/xtcp/destinations_s3parquet.go index e9e39bb..0138be1 100644 --- a/pkg/xtcp/destinations_s3parquet.go +++ b/pkg/xtcp/destinations_s3parquet.go @@ -777,6 +777,7 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { InetDiagMsgSocketDestAsn: r.InetDiagMsgSocketDestAsn, InetDiagMsgSocketNextHopAsn: r.InetDiagMsgSocketNextHopAsn, InetDiagMsgSocketDestNetworkOwner: r.InetDiagMsgSocketDestNetworkOwner, + InetDiagMsgSocketDestLocality: int32(r.InetDiagMsgSocketDestLocality), InetDiagMsgExpires: r.InetDiagMsgExpires, InetDiagMsgRqueue: r.InetDiagMsgRqueue, InetDiagMsgWqueue: r.InetDiagMsgWqueue, diff --git a/pkg/xtcp/destinations_s3parquet_schema.go b/pkg/xtcp/destinations_s3parquet_schema.go index e60da54..ecdcd89 100644 --- a/pkg/xtcp/destinations_s3parquet_schema.go +++ b/pkg/xtcp/destinations_s3parquet_schema.go @@ -54,6 +54,7 @@ type ParquetRow struct { InetDiagMsgSocketDestAsn uint64 `parquet:"inet_diag_msg_socket_dest_asn,snappy"` InetDiagMsgSocketNextHopAsn uint64 `parquet:"inet_diag_msg_socket_next_hop_asn,snappy"` InetDiagMsgSocketDestNetworkOwner string `parquet:"inet_diag_msg_socket_dest_network_owner,snappy"` + InetDiagMsgSocketDestLocality int32 `parquet:"inet_diag_msg_socket_dest_locality,snappy"` InetDiagMsgExpires uint32 `parquet:"inet_diag_msg_expires,snappy"` InetDiagMsgRqueue uint32 `parquet:"inet_diag_msg_rqueue,snappy"` InetDiagMsgWqueue uint32 `parquet:"inet_diag_msg_wqueue,snappy"` diff --git a/pkg/xtcp/enrich.go b/pkg/xtcp/enrich.go index 0699227..2b2ea7b 100644 --- a/pkg/xtcp/enrich.go +++ b/pkg/xtcp/enrich.go @@ -13,6 +13,7 @@ import ( "github.com/randomizedcoder/xtcp2/pkg/dockermeta" "github.com/randomizedcoder/xtcp2/pkg/ipasn" "github.com/randomizedcoder/xtcp2/pkg/lldp" + "github.com/randomizedcoder/xtcp2/pkg/localnet" "github.com/randomizedcoder/xtcp2/pkg/nicinfo" "github.com/randomizedcoder/xtcp2/pkg/nsdiscover" ) @@ -100,6 +101,7 @@ func (x *XTCP) initEnrichers(ctx context.Context) { x.initDockerEnricher(ctx) x.initUplinkEnrichers(ctx) x.initAsnEnricher(ctx) + x.initLocalityEnricher() } // initAsnEnricher loads the ipfeed-collector Parquet artifact into an in-process @@ -301,8 +303,21 @@ func (x *XTCP) applyEnrichment(r *xtcp_flat_record.XtcpFlatRecord) { } } - if x.asnIndex != nil { - if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok { + if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok { + // Classify the destination's locality first. remote defaults to true so + // that with locality disabled (nil map) or no snapshot for this namespace + // the ASN lookup runs exactly as before. A self / connected-subnet + // destination is tagged and skips the internet ASN feed. + remote := true + if m := x.localityByInode.Load(); m != nil { + if snap := (*m)[r.NetnsInode]; snap != nil { + loc := snap.Classify(addr) + r.InetDiagMsgSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(loc) + remote = loc == localnet.LocalityRemote + } + } + + if remote && x.asnIndex != nil { if a, found := x.asnIndex.Lookup(addr); found { r.InetDiagMsgSocketDestAsn = uint64(a.ASN) r.InetDiagMsgSocketDestNetworkOwner = a.NetworkOwner diff --git a/pkg/xtcp/enrich_locality.go b/pkg/xtcp/enrich_locality.go new file mode 100644 index 0000000..ef9ad6e --- /dev/null +++ b/pkg/xtcp/enrich_locality.go @@ -0,0 +1,215 @@ +package xtcp + +import ( + "log" + "runtime" + "time" + + "golang.org/x/sys/unix" + + "github.com/randomizedcoder/xtcp2/pkg/localnet" + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// localityRecvTimeout bounds each rtnetlink dump's recv so a missing NLMSG_DONE +// degrades to a discovery error (that namespace stays unclassified) instead of +// blocking the reconcile owner. +var localityRecvTimeout = unix.Timeval{Sec: 2} + +// initLocalityEnricher records that locality classification is enabled. The +// actual per-namespace discovery is driven by the single-owner reconcile path +// (refreshLocality, called from discoverNamespaces), so there is nothing to +// load or spawn here — this just logs intent and bumps a counter, mirroring the +// other initEnrichers gates. +func (x *XTCP) initLocalityEnricher() { + if !x.config.EnrichLocalityEnable { + return + } + x.pC.WithLabelValues("initEnrichers", "locality", "enabled").Inc() + if x.debugLevel > 10 { + log.Printf("initLocalityEnricher: locality enrichment enabled (refresh:%s); per-namespace discovery runs on the reconcile path", + x.config.GetLocalityRefreshInterval().AsDuration()) + } +} + +// refreshLocality rebuilds the netns-inode -> locality snapshot for the current +// namespace set and publishes it atomically for the stamping path. It is called +// only from the single-owner reconcile path (discoverNamespaces) under +// reconcileMu, so lastLocalityRefresh needs no additional lock. +// +// It is throttled by locality_refresh_interval: a "full" pass re-discovers every +// namespace, while intervening passes only discover namespaces that appeared +// since the last snapshot (so a new container is classified promptly without +// re-dumping every existing namespace every reconcile). A namespace whose +// discovery fails keeps its previous snapshot rather than dropping to +// unclassified. interval <= 0 means discover each namespace once and never +// refresh it (new namespaces are still picked up). +func (x *XTCP) refreshLocality(nss map[uint64]nsIdentity) { + now := time.Now() + interval := x.config.GetLocalityRefreshInterval().AsDuration() + full := x.lastLocalityRefresh.IsZero() || (interval > 0 && now.Sub(x.lastLocalityRefresh) >= interval) + + var cur map[uint64]*localnet.Snapshot + if p := x.localityByInode.Load(); p != nil { + cur = *p + } + + m := make(map[uint64]*localnet.Snapshot, len(nss)) + for inode, id := range nss { + if !full { + if snap, ok := cur[inode]; ok { + m[inode] = snap // reuse; between full passes only new namespaces are dumped + continue + } + } + if snap, ok := x.nsLocalitySnapshot(id); ok { + m[inode] = snap + } else if snap, had := cur[inode]; had { + m[inode] = snap // keep the last good snapshot on a discovery failure + } + } + + x.localityByInode.Store(&m) + if full { + x.lastLocalityRefresh = now + } + x.pC.WithLabelValues("refreshLocality", "namespaces", "counter").Add(float64(len(m))) +} + +// nsLocalitySnapshot enters the namespace referenced by id, dumps its links, +// addresses and routes via rtnetlink, and returns the built snapshot. It runs on +// a dedicated OS thread that it deliberately never unlocks: after setns the +// thread is netns-tainted, so on return the Go runtime terminates it instead of +// recycling it — the same safety property netNamespaceInstance relies on to +// avoid the tainted-M thread-exhaustion regression. These dumps are infrequent +// (throttled by locality_refresh_interval), so the per-call thread teardown is +// cheap. Best-effort: any error yields (nil, false). +func (x *XTCP) nsLocalitySnapshot(id nsIdentity) (*localnet.Snapshot, bool) { + handle := id.path + if handle == "" { + handle = procNsPath(id.pid) + } + + type result struct { + snap *localnet.Snapshot + ok bool + } + ch := make(chan result, 1) + + go func() { + runtime.LockOSThread() //nolint:forbidigo // intentional: thread is netns-tainted after setns; goroutine returns without UnlockOSThread so the runtime terminates it (no tainted-M reuse). + + fd, err := unix.Open(handle, unix.O_RDONLY|unix.O_CLOEXEC, 0) + if err != nil { + x.pC.WithLabelValues("refreshLocality", "open", "error").Inc() + ch <- result{} + return + } + defer func() { + if cerr := unix.Close(fd); cerr != nil { + x.pC.WithLabelValues("refreshLocality", "closeHandle", "error").Inc() + } + }() + + if err := unix.Setns(fd, unix.CLONE_NEWNET); err != nil { + x.pC.WithLabelValues("refreshLocality", "setns", "error").Inc() + ch <- result{} + return + } + + snap, err := x.dumpLocalityInNs() + if err != nil { + x.pC.WithLabelValues("refreshLocality", "dump", "error").Inc() + ch <- result{} + return + } + ch <- result{snap: snap, ok: true} + }() + + r := <-ch + return r.snap, r.ok +} + +// dumpLocalityInNs opens a NETLINK_ROUTE socket in the caller's current network +// namespace and dumps its links (RTM_GETLINK), addresses (RTM_GETADDR) and +// routes (RTM_GETROUTE), building a locality Snapshot. The socket is pinned to +// the namespace it is created in, so this must be called while the OS thread is +// in the target namespace (see nsLocalitySnapshot). AF_UNSPEC dumps both IPv4 +// and IPv6, and the route dump returns all tables (main + local), so RTN_LOCAL +// entries are included. +func (x *XTCP) dumpLocalityInNs() (*localnet.Snapshot, error) { + fd, err := unix.Socket(unix.AF_NETLINK, unix.SOCK_RAW|unix.SOCK_CLOEXEC, unix.NETLINK_ROUTE) + if err != nil { + return nil, err + } + defer func() { + if cerr := unix.Close(fd); cerr != nil { + x.pC.WithLabelValues("dumpLocality", "closeSocket", "error").Inc() + } + }() + + sa := &unix.SockaddrNetlink{Family: unix.AF_NETLINK} + if err := unix.Bind(fd, sa); err != nil { + return nil, err + } + tv := localityRecvTimeout + if err := unix.SetsockoptTimeval(fd, unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv); err != nil { + return nil, err + } + + var seq uint32 + + // Links: traverse for a per-namespace link count (diagnostics); the + // classification itself needs only addresses + routes. + links := make(map[int32]string) + seq++ + if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpLinkRequest(seq), sa, func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWLINK) { + li, perr := xtcpnl.ParseNewLink(body) + if perr != nil { + return perr + } + links[li.Index] = li.Name + } + return nil + }); err != nil { + return nil, err + } + + // Addresses (both families). + var addrs []xtcpnl.AddrInfo + seq++ + if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpAddrRequest(unix.AF_UNSPEC, seq), sa, func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWADDR) { + ai, perr := xtcpnl.ParseNewAddr(body) + if perr != nil { + return perr + } + addrs = append(addrs, ai) + } + return nil + }); err != nil { + return nil, err + } + + // Routes (both families, all tables). + var routes []xtcpnl.RouteInfo + seq++ + if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpRouteRequest(unix.AF_UNSPEC, seq), sa, func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWROUTE) { + ri, perr := xtcpnl.ParseNewRoute(body) + if perr != nil { + return perr + } + routes = append(routes, ri) + } + return nil + }); err != nil { + return nil, err + } + + if x.debugLevel > 10 { + log.Printf("dumpLocalityInNs: links:%d addrs:%d routes:%d", len(links), len(addrs), len(routes)) + } + return localnet.BuildSnapshot(addrs, routes), nil +} diff --git a/pkg/xtcp/ns_discover.go b/pkg/xtcp/ns_discover.go index e9fc520..36cedfb 100644 --- a/pkg/xtcp/ns_discover.go +++ b/pkg/xtcp/ns_discover.go @@ -85,5 +85,12 @@ func (x *XTCP) discoverNamespaces() map[uint64]nsIdentity { x.refreshNsids(out) } + // Opt-in per-namespace locality snapshot (self / connected-subnet / remote), + // throttled by locality_refresh_interval. Single-owner (reconcile) — see + // enrich_locality.go. + if x.config != nil && x.config.EnrichLocalityEnable { + x.refreshLocality(out) + } + return out } diff --git a/pkg/xtcp/xtcp.go b/pkg/xtcp/xtcp.go index 64ff10e..895a110 100644 --- a/pkg/xtcp/xtcp.go +++ b/pkg/xtcp/xtcp.go @@ -21,6 +21,7 @@ import ( "github.com/randomizedcoder/xtcp2/pkg/cgroupid" "github.com/randomizedcoder/xtcp2/pkg/dockermeta" "github.com/randomizedcoder/xtcp2/pkg/ipasn" + "github.com/randomizedcoder/xtcp2/pkg/localnet" "github.com/randomizedcoder/xtcp2/pkg/misc" "github.com/randomizedcoder/xtcp2/pkg/nsdiscover" "github.com/randomizedcoder/xtcp2/pkg/xsync" @@ -123,6 +124,16 @@ type XTCP struct { // stamping path. nil unless enrich_asn_enable and a readable asn_db_path. asnIndex *ipasn.Index + // localityByInode maps a socket's netns inode -> that namespace's local + // address/route snapshot, used to classify a destination as self / + // connected-subnet / remote BEFORE the ASN lookup. Rebuilt on the + // single-owner reconcile path (refreshLocality) and read lock-free on the + // stamping path. nil/empty unless enrich_locality_enable. lastLocalityRefresh + // throttles the per-namespace rtnetlink discovery to locality_refresh_interval + // and is touched only under reconcileMu (the reconcile owner). + localityByInode atomic.Pointer[map[uint64]*localnet.Snapshot] + lastLocalityRefresh time.Time + RTATypeDeserializer map[int]func(buf []byte, xtcpRecord *xtcp_flat_record.XtcpFlatRecord) (err error) RTATypeDeserializerStr map[int]string diff --git a/pkg/xtcpnl/testdata/7_1_8/ip_addr_n b/pkg/xtcpnl/testdata/7_1_8/ip_addr_n new file mode 100644 index 0000000..2f84e05 --- /dev/null +++ b/pkg/xtcpnl/testdata/7_1_8/ip_addr_n @@ -0,0 +1,82 @@ +1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000 + link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 promiscuity 0 allmulti 0 minmtu 0 maxmtu 0 netns-immutable numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet 127.0.0.1/8 scope host lo + valid_lft forever preferred_lft forever + inet6 ::1/128 scope host noprefixroute + valid_lft forever preferred_lft forever +2: enp1s0: mtu 1500 qdisc mq state UP group default qlen 1000 + link/ether e0:4f:43:e6:28:ef brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 16334 numtxqueues 32 numrxqueues 32 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 parentbus pci parentdev 0000:01:00.0 + altname enxe04f43e628ef + inet 172.16.50.219/24 brd 172.16.50.255 scope global dynamic noprefixroute enp1s0 + valid_lft 47871sec preferred_lft 47871sec + inet6 2603:8002:ea00:6800:9f01:bd3f:fc61:bc7c/64 scope global temporary dynamic + valid_lft 86398sec preferred_lft 33980sec + inet6 2603:8002:ea00:6800:827f:e158:2c1c:13b4/64 scope global temporary deprecated dynamic + valid_lft 34941sec preferred_lft 0sec + inet6 2603:8002:ea00:6800:6adf:8a2f:21ae:d6a7/64 scope global dynamic mngtmpaddr noprefixroute + valid_lft 86398sec preferred_lft 86398sec + inet6 fe80::b5c8:b23e:9a98:a37c/64 scope link noprefixroute + valid_lft forever preferred_lft forever +3: enp35s0f0np0: mtu 1500 qdisc mq state UP group default qlen 1000 + link/ether 04:09:73:cf:d8:d0 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 9978 numtxqueues 192 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 portname p0 switchid d0d8cfffff730904 parentbus pci parentdev 0000:23:00.0 + altname enx040973cfd8d0 + inet 10.10.4.2/29 scope global enp35s0f0np0 + valid_lft forever preferred_lft forever + inet6 fd10:10:4::2/64 scope global nodad + valid_lft forever preferred_lft forever + inet6 fe80::609:73ff:fecf:d8d0/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +4: enp35s0f1np1: mtu 1500 qdisc mq state UP group default qlen 1000 + link/ether 04:09:73:cf:d8:d1 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 9978 numtxqueues 192 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 portname p1 switchid d0d8cfffff730904 parentbus pci parentdev 0000:23:00.1 + altname enx040973cfd8d1 + inet 10.10.5.2/29 scope global enp35s0f1np1 + valid_lft forever preferred_lft forever + inet6 fd10:10:5::2/64 scope global nodad + valid_lft forever preferred_lft forever + inet6 fe80::609:73ff:fecf:d8d1/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +7: virbr0: mtu 1500 qdisc noqueue state DOWN group default qlen 1000 + link/ether 52:54:00:52:00:04 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 200 hello_time 200 max_age 2000 ageing_time 30000 stp_state 1 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.52:54:0:52:0:4 designated_root 8000.52:54:0:52:0:4 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 1.30 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 244.80 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet 192.168.122.1/24 brd 192.168.122.255 scope global virbr0 + valid_lft forever preferred_lft forever +8: docker0: mtu 1500 qdisc noqueue state DOWN group default + link/ether a6:56:62:1d:73:01 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 1500 hello_time 200 max_age 2000 ageing_time 30000 stp_state 0 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.a6:56:62:1d:73:1 designated_root 8000.a6:56:62:1d:73:1 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 0.00 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 0.00 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0 + valid_lft forever preferred_lft forever + inet6 fd00::1/80 scope global nodad + valid_lft forever preferred_lft forever + inet6 fe80::a456:62ff:fe1d:7301/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +9: br-3a5828b2963a: mtu 1500 qdisc noqueue state UP group default + link/ether 7a:d0:e5:3a:7c:78 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 1500 hello_time 200 max_age 2000 ageing_time 30000 stp_state 0 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.7a:d0:e5:3a:7c:78 designated_root 8000.7a:d0:e5:3a:7c:78 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 0.00 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 179.27 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet 172.18.0.1/16 brd 172.18.255.255 scope global br-3a5828b2963a + valid_lft forever preferred_lft forever + inet6 fe80::78d0:e5ff:fe3a:7c78/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +58: ve-nfb-vpn@if2: mtu 1500 qdisc noqueue state UP group default qlen 1000 + link/ether 6e:05:d5:51:50:25 brd ff:ff:ff:ff:ff:ff link-netnsid 1 promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 + veth numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet 10.98.0.1/32 scope global ve-nfb-vpn + valid_lft forever preferred_lft forever + inet6 fe80::6c05:d5ff:fe51:5025/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +59: ve-nordlayepDd-@if2: mtu 1500 qdisc noqueue state UP group default qlen 1000 + link/ether 66:cf:08:aa:09:d9 brd ff:ff:ff:ff:ff:ff link-netnsid 2 promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 + veth numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + altname ve-nordlayer-vpn + inet 10.99.0.1/32 scope global ve-nordlayepDd- + valid_lft forever preferred_lft forever + inet6 fe80::64cf:8ff:feaa:9d9/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +60: veth179a698@if2: mtu 1500 qdisc noqueue master br-3a5828b2963a state UP group default + link/ether aa:1f:d4:5f:c8:d6 brd ff:ff:ff:ff:ff:ff link-netnsid 3 promiscuity 1 allmulti 1 minmtu 68 maxmtu 65535 + veth + bridge_slave state forwarding priority 32 cost 2 hairpin on guard off root_block off fastleave off learning on flood on port_id 0x8001 port_no 0x1 designated_port 32769 designated_cost 0 designated_bridge 8000.7a:d0:e5:3a:7c:78 designated_root 8000.7a:d0:e5:3a:7c:78 hold_timer 0.00 message_age_timer 0.00 forward_delay_timer 0.00 topology_change_ack 0 config_pending 0 proxy_arp off proxy_arp_wifi off mcast_router 1 mcast_fast_leave off mcast_flood on bcast_flood on mcast_to_unicast off neigh_suppress off neigh_vlan_suppress off group_fwd_mask 0 group_fwd_mask_str 0x0 vlan_tunnel off isolated off locked off mab off numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + inet6 fe80::fc23:7fff:feb7:7f1d/64 scope link proto kernel_ll + valid_lft forever preferred_lft forever +161: nlmon0: mtu 3776 qdisc noqueue state UNKNOWN group default qlen 1000 + link/netlink promiscuity 0 allmulti 0 minmtu 16 maxmtu 0 + nlmon numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 diff --git a/pkg/xtcpnl/testdata/7_1_8/ip_link_n b/pkg/xtcpnl/testdata/7_1_8/ip_link_n new file mode 100644 index 0000000..5e4a0e2 --- /dev/null +++ b/pkg/xtcpnl/testdata/7_1_8/ip_link_n @@ -0,0 +1,34 @@ +1: lo: mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000 + link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 promiscuity 0 allmulti 0 minmtu 0 maxmtu 0 netns-immutable addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +2: enp1s0: mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000 + link/ether e0:4f:43:e6:28:ef brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 16334 addrgenmode none numtxqueues 32 numrxqueues 32 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 parentbus pci parentdev 0000:01:00.0 + altname enxe04f43e628ef +3: enp35s0f0np0: mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000 + link/ether 04:09:73:cf:d8:d0 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 9978 addrgenmode eui64 numtxqueues 192 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 portname p0 switchid d0d8cfffff730904 parentbus pci parentdev 0000:23:00.0 + altname enx040973cfd8d0 +4: enp35s0f1np1: mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000 + link/ether 04:09:73:cf:d8:d1 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 9978 addrgenmode eui64 numtxqueues 192 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 portname p1 switchid d0d8cfffff730904 parentbus pci parentdev 0000:23:00.1 + altname enx040973cfd8d1 +7: virbr0: mtu 1500 qdisc noqueue state DOWN mode DEFAULT group default qlen 1000 + link/ether 52:54:00:52:00:04 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 200 hello_time 200 max_age 2000 ageing_time 30000 stp_state 1 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.52:54:0:52:0:4 designated_root 8000.52:54:0:52:0:4 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 1.26 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 244.76 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +8: docker0: mtu 1500 qdisc noqueue state DOWN mode DEFAULT group default + link/ether a6:56:62:1d:73:01 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 1500 hello_time 200 max_age 2000 ageing_time 30000 stp_state 0 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.a6:56:62:1d:73:1 designated_root 8000.a6:56:62:1d:73:1 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 0.00 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 0.00 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +9: br-3a5828b2963a: mtu 1500 qdisc noqueue state UP mode DEFAULT group default + link/ether 7a:d0:e5:3a:7c:78 brd ff:ff:ff:ff:ff:ff promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 netns-immutable + bridge forward_delay 1500 hello_time 200 max_age 2000 ageing_time 30000 stp_state 0 priority 32768 vlan_filtering 0 vlan_protocol 802.1Q bridge_id 8000.7a:d0:e5:3a:7c:78 designated_root 8000.7a:d0:e5:3a:7c:78 root_port 0 root_path_cost 0 topology_change 0 topology_change_detected 0 hello_timer 0.00 tcn_timer 0.00 topology_change_timer 0.00 gc_timer 179.23 fdb_n_learned 0 fdb_max_learned 0 vlan_default_pvid 1 vlan_stats_enabled 0 vlan_stats_per_port 0 group_fwd_mask 0 group_address 01:80:c2:00:00:00 mcast_snooping 1 no_linklocal_learn 0 mcast_vlan_snooping 0 mst_enabled 0 mdb_offload_fail_notification 0 fdb_local_vlan_0 0 mcast_router 1 mcast_query_use_ifaddr 0 mcast_querier 0 mcast_hash_elasticity 16 mcast_hash_max 4096 mcast_last_member_count 2 mcast_startup_query_count 2 mcast_last_member_interval 100 mcast_membership_interval 26000 mcast_querier_interval 25500 mcast_query_interval 12500 mcast_query_response_interval 1000 mcast_startup_query_interval 3125 mcast_stats_enabled 0 mcast_igmp_version 2 mcast_mld_version 1 nf_call_iptables 0 nf_call_ip6tables 0 nf_call_arptables 0 addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +58: ve-nfb-vpn@if2: mtu 1500 qdisc noqueue state UP mode DEFAULT group default qlen 1000 + link/ether 6e:05:d5:51:50:25 brd ff:ff:ff:ff:ff:ff link-netnsid 1 promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 + veth addrgenmode eui64 numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +59: ve-nordlayepDd-@if2: mtu 1500 qdisc noqueue state UP mode DEFAULT group default qlen 1000 + link/ether 66:cf:08:aa:09:d9 brd ff:ff:ff:ff:ff:ff link-netnsid 2 promiscuity 0 allmulti 0 minmtu 68 maxmtu 65535 + veth addrgenmode eui64 numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 + altname ve-nordlayer-vpn +60: veth179a698@if2: mtu 1500 qdisc noqueue master br-3a5828b2963a state UP mode DEFAULT group default + link/ether aa:1f:d4:5f:c8:d6 brd ff:ff:ff:ff:ff:ff link-netnsid 3 promiscuity 1 allmulti 1 minmtu 68 maxmtu 65535 + veth + bridge_slave state forwarding priority 32 cost 2 hairpin on guard off root_block off fastleave off learning on flood on port_id 0x8001 port_no 0x1 designated_port 32769 designated_cost 0 designated_bridge 8000.7a:d0:e5:3a:7c:78 designated_root 8000.7a:d0:e5:3a:7c:78 hold_timer 0.00 message_age_timer 0.00 forward_delay_timer 0.00 topology_change_ack 0 config_pending 0 proxy_arp off proxy_arp_wifi off mcast_router 1 mcast_fast_leave off mcast_flood on bcast_flood on mcast_to_unicast off neigh_suppress off neigh_vlan_suppress off group_fwd_mask 0 group_fwd_mask_str 0x0 vlan_tunnel off isolated off locked off mab off addrgenmode eui64 numtxqueues 24 numrxqueues 24 gso_max_size 65536 gso_max_segs 65535 tso_max_size 524280 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 +161: nlmon0: mtu 3776 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000 + link/netlink promiscuity 0 allmulti 0 minmtu 16 maxmtu 0 + nlmon addrgenmode eui64 numtxqueues 1 numrxqueues 1 gso_max_size 65536 gso_max_segs 65535 tso_max_size 65536 tso_max_segs 65535 gro_max_size 65536 gso_ipv4_max_size 65536 gro_ipv4_max_size 65536 diff --git a/pkg/xtcpnl/testdata/7_1_8/ip_route_table_all_n b/pkg/xtcpnl/testdata/7_1_8/ip_route_table_all_n new file mode 100644 index 0000000..141b9c8 --- /dev/null +++ b/pkg/xtcpnl/testdata/7_1_8/ip_route_table_all_n @@ -0,0 +1,74 @@ +unicast default via 172.16.50.1 dev enp1s0 table main proto dhcp scope global src 172.16.50.219 metric 100 +unicast 10.10.4.0/29 dev enp35s0f0np0 table main proto kernel scope link src 10.10.4.2 +unicast 10.10.5.0/29 dev enp35s0f1np1 table main proto kernel scope link src 10.10.5.2 +unicast 10.98.0.2 dev ve-nfb-vpn table main proto boot scope link +unicast 10.99.0.2 dev ve-nordlayepDd- table main proto boot scope link +unicast 172.16.50.0/24 dev enp1s0 table main proto kernel scope link src 172.16.50.219 metric 100 +unicast 172.17.0.0/16 dev docker0 table main proto kernel scope link src 172.17.0.1 linkdown +unicast 172.18.0.0/16 dev br-3a5828b2963a table main proto kernel scope link src 172.18.0.1 +unicast 192.168.122.0/24 dev virbr0 table main proto kernel scope link src 192.168.122.1 linkdown +local 10.10.4.2 dev enp35s0f0np0 table local proto kernel scope host src 10.10.4.2 +broadcast 10.10.4.7 dev enp35s0f0np0 table local proto kernel scope link src 10.10.4.2 +local 10.10.5.2 dev enp35s0f1np1 table local proto kernel scope host src 10.10.5.2 +broadcast 10.10.5.7 dev enp35s0f1np1 table local proto kernel scope link src 10.10.5.2 +local 10.98.0.1 dev ve-nfb-vpn table local proto kernel scope host src 10.98.0.1 +local 10.99.0.1 dev ve-nordlayepDd- table local proto kernel scope host src 10.99.0.1 +local 127.0.0.0/8 dev lo table local proto kernel scope host src 127.0.0.1 +local 127.0.0.1 dev lo table local proto kernel scope host src 127.0.0.1 +broadcast 127.255.255.255 dev lo table local proto kernel scope link src 127.0.0.1 +local 172.16.50.219 dev enp1s0 table local proto kernel scope host src 172.16.50.219 +broadcast 172.16.50.255 dev enp1s0 table local proto kernel scope link src 172.16.50.219 +local 172.17.0.1 dev docker0 table local proto kernel scope host src 172.17.0.1 +broadcast 172.17.255.255 dev docker0 table local proto kernel scope link src 172.17.0.1 linkdown +local 172.18.0.1 dev br-3a5828b2963a table local proto kernel scope host src 172.18.0.1 +broadcast 172.18.255.255 dev br-3a5828b2963a table local proto kernel scope link src 172.18.0.1 +local 192.168.122.1 dev virbr0 table local proto kernel scope host src 192.168.122.1 +broadcast 192.168.122.255 dev virbr0 table local proto kernel scope link src 192.168.122.1 linkdown +unicast 2603:8002:ea00:6800::/64 dev enp1s0 table main proto ra scope global metric 100 pref medium +unicast fd00::/80 dev docker0 table main proto kernel scope global metric 256 linkdown pref medium +unicast fd10:10:4::/64 dev enp35s0f0np0 table main proto kernel scope global metric 256 pref medium +unicast fd10:10:5::/64 dev enp35s0f1np1 table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev enp35s0f0np0 table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev enp35s0f1np1 table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev br-3a5828b2963a table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev docker0 table main proto kernel scope global metric 256 linkdown pref medium +unicast fe80::/64 dev ve-nfb-vpn table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev ve-nordlayepDd- table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev veth179a698 table main proto kernel scope global metric 256 pref medium +unicast fe80::/64 dev enp1s0 table main proto kernel scope global metric 1024 pref medium +unicast default via fe80::e638:83ff:fe36:8f0d dev enp1s0 table main proto ra scope global metric 100 pref high +local ::1 dev lo table local proto kernel scope global metric 0 pref medium +anycast 2603:8002:ea00:6800:: dev enp1s0 table local proto kernel scope global metric 0 pref medium +local 2603:8002:ea00:6800:6adf:8a2f:21ae:d6a7 dev enp1s0 table local proto kernel scope global metric 0 pref medium +local 2603:8002:ea00:6800:827f:e158:2c1c:13b4 dev enp1s0 table local proto kernel scope global metric 0 pref medium +local 2603:8002:ea00:6800:9f01:bd3f:fc61:bc7c dev enp1s0 table local proto kernel scope global metric 0 pref medium +anycast fd00:: dev docker0 table local proto kernel scope global metric 0 pref medium +local fd00::1 dev docker0 table local proto kernel scope global metric 0 pref medium +anycast fd10:10:4:: dev enp35s0f0np0 table local proto kernel scope global metric 0 pref medium +local fd10:10:4::2 dev enp35s0f0np0 table local proto kernel scope global metric 0 pref medium +anycast fd10:10:5:: dev enp35s0f1np1 table local proto kernel scope global metric 0 pref medium +local fd10:10:5::2 dev enp35s0f1np1 table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev enp1s0 table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev enp35s0f0np0 table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev enp35s0f1np1 table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev br-3a5828b2963a table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev docker0 table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev ve-nfb-vpn table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev ve-nordlayepDd- table local proto kernel scope global metric 0 pref medium +anycast fe80:: dev veth179a698 table local proto kernel scope global metric 0 pref medium +local fe80::609:73ff:fecf:d8d0 dev enp35s0f0np0 table local proto kernel scope global metric 0 pref medium +local fe80::609:73ff:fecf:d8d1 dev enp35s0f1np1 table local proto kernel scope global metric 0 pref medium +local fe80::64cf:8ff:feaa:9d9 dev ve-nordlayepDd- table local proto kernel scope global metric 0 pref medium +local fe80::6c05:d5ff:fe51:5025 dev ve-nfb-vpn table local proto kernel scope global metric 0 pref medium +local fe80::78d0:e5ff:fe3a:7c78 dev br-3a5828b2963a table local proto kernel scope global metric 0 pref medium +local fe80::a456:62ff:fe1d:7301 dev docker0 table local proto kernel scope global metric 0 pref medium +local fe80::b5c8:b23e:9a98:a37c dev enp1s0 table local proto kernel scope global metric 0 pref medium +local fe80::fc23:7fff:feb7:7f1d dev veth179a698 table local proto kernel scope global metric 0 pref medium +multicast ff00::/8 dev enp35s0f0np0 table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev enp35s0f1np1 table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev enp1s0 table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev br-3a5828b2963a table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev docker0 table local proto kernel scope global metric 256 linkdown pref medium +multicast ff00::/8 dev ve-nfb-vpn table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev ve-nordlayepDd- table local proto kernel scope global metric 256 pref medium +multicast ff00::/8 dev veth179a698 table local proto kernel scope global metric 256 pref medium diff --git a/pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr.pcap b/pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr.pcap new file mode 100644 index 0000000000000000000000000000000000000000..4dd0160e7e3b85128d581dc5c29aa7812576d0ca GIT binary patch literal 78216 zcmeHQ37i$hnXh*Zk8#j}84;CZkV9ic24*0Dg0mvZ0s;~QOo%!#GYkf~bv-aVkQm~z zWCM5*Q51h(D5AzS5y%2DN;WE(2qJOU1H9OcZdTSSFmJzqRe#gf^}2idF>i(=UBBP= zs=Hp-zrL#as=m7V>omSU-5|CelT*NF*k= ziik0Hwi5XjLPTX)RCJG}qWeUxxayr-dv;#C^O0f^aS6*4sY@b~7&9r7Lc~z&sy)5U0g`!YU{a7xlm-C335>g%f_b&zqGpS+fH z(skQ*ZP#&X5<-9^KZKDG$I0|F^S4m4g8G+yQ5?%T_!>z(f&BPFmVjgM_4*<4HF_cO zZj~2vqZ7ic>J3;5fp@Wf;i~c zqDj@SB}pFVQ$L%e|KPVEZl=w!>qXB4_i+<;UTt(Xy(i&+Ij) zRN>O!#7mw?tfzKI)Q1FcRcdHF1GhtpVj@mNgD?w4Ff?LxP>XgRJc#HR&}L(D&N-WbODt|)r`qMtR`TVFC72xvSPMY1Ltg=tP-u))^?%%hp(iQ(?0s)OR@k>$yZC94_B!!<({t1M8 zZFP_7HIsT=J99ezC!Hzd+WPcvYI~rJvLH;fUx_){!XzKO0&~Xfs%e$iSI@kls)sA? zlY|LEd)c+if9!yE$?b)blx=L|3o&sPU4zUv)}Deoib!naPc}UK7_E2d4(aWtxEqca zlFYax=;8L19>+zSM%`3U6G2|z72 zld_E#0IOta|79I7a$?>5;-6wgPb%`mstCZ>g08jk)~yuzVG(c4R|I_R?RRtEB?XEv z+XQFyjSiX80qm_MSfUX8GQ__{ry|ED|%UBfeGYsKXnqr zPEmv~w>+YZDy%$ymQH_T@ijmFjgzlsC)dWiMio(%2C?3yp>};9+d8pI?wk@|_ajAK zSZLD~0r*<~>$1r32Nii?A&;7@C%{+jn=4McS?aYowE$IKdnUDxfQF509jG2Z6k>9H z9w$5VxQXgi!bzr6#?X{nA-D0s}*@+8F@Spe0{aMVCW@(amvKXjYVSq<|1*^ zvqgaNtVgZ9#sOd&P;h=klZgts4t%t4bFd0`nc z;fd9f%Ih8~E07nKQC>f?WMY2NUT1mTG%_B>$9G2!{;I;&OEmLL!kie*-!|!T=NL|qPmpjl|NZTftB~#o=2~c z<7~UXU)M&>Q_ARhukwNrR|L>QLCVXJ)#Jcd>A#Np-S`D6kCc?u+b!6)xWY%4uF?D0&4s89G++tIxz9dQK6r-15uyp!49z59h+mKwt}5S@ zqux(j+FwLzb^(6%c?N_BW7T<|3rWNF0M)(T&ZY1Qw{oDh6{{TR%2^JrXk4+9#)lx_ z2A0#*C*_O&_|@@xU0pWjtmr2L6amXkwtULeQwElj40NIL1bN}AGR3@BYfE?h*R7u) z|KTX)eaky-R@9Aj=6%I;pGV6-eJpn7eV-$`E5GO~DNzS*{IxylI_fQftM{A0kaI68 z)16eFAcSEq`z6g~U!=J#sG+&6SKm-r{D+lizBTqnz0C7JeKE3Pry``~R_1PH^TpKj z({)2Gy$5;NKlOaNa+b|sfBI!?!E8l-xD{^lMtgLYywQ~tchk&2iqV%T^1?--x!~e) z+3s)wrrgOgSIu^AJBRH;lq>SfBR=eUOamA2YB3*$9rkMcoxYm$O{+pRN+?dKl|gS zR=v}eGw&^a^Zn>u4=c(N7ms`LyOjFzF0^I>^20UT@ZBq4N!NXR=Wg)3V&yAz<>Yrr z#~#rgd5ZjSE8NQA;>w9uInb38cg#b(BJba>C~Mqgy9pL9T{&^z%>N)Z<@3FgfZLF4 z@p-b1TW_xG+UK-0|IN;~$Z{f(`-KQ%^Rue(2Q)7QdSJ zljswpd+9Rpm%r|g-LzYgACG3cx-YRaUAL~h26c6BVkccW>#Fefn)s@@iu`b+!Z|+r zu;0z;y1q+V0ast|M8!boo<@GRo?T*Xi4f-2XQQr6emA}RQMzu<(<$I?dHEx{a`Joq zDShHCV~QwxVBGv?JGUCy{ufE$Zu-AIr$1lp#N9t?QhZTAMP9fNjtaN_W!tXTflK3B zx^m)vPGhB;X`BS|!gVW$aT~8s*U>5paP{>RV4!>pmwg#qHBXTjF0T({qZ7@w0M#4ShV(*R3aJZG&~D4WzP9zU|JL*V=0)A3Q%V)#8MnOq$be^m_|g-d#JJ^(fE$!Y zal<2dH4_ux(s`V9<9Q-drO1m%&w79U*=wwNrz>YUKJey$Mtf~i6%ak7m&5y~iJMFt2&aWX! z)v<=`|Bcx3wjwVck#|#03$Ob5@1Oemsvm&I75P7ZwB1lAk6W+V8+-c4J>nBC--|5D zIc?thm>8Q!``AS0oYt)_edO4)Z`eg+##&lq1tDEGT+h0^y4?n=F6qjdpYQ#(GPdt6 zMP9fN%8E?=fX6-OBj?gQ^cB**AUx>CuZK+g;@(U$T}1K>^1}5j2YO$`DhIl9mO}~6 zpVrYD7|0LTl$YXDM$Y`VGf!ONB`>!PSQ{-G-#K<_m$hKawH!S8rL%ArzjWo~_Z#B( zR_ZT6UbvoZ(5K!8QoX%Obq4an^_cTS(sUNe;+L+R{QiaN?Ix--kQc58zY!YUZMSgg z%8C0mjq`p=yn?)NQNCuq)wHci*Il#wS>RT+t)VL??tew@i`}?yrKD_dXSbY{uA`ks z;Ocvhz`*$CyyaiUw%w#C8(gvf*^TF}-nkUGZfkgR-`Or^{(4X}zLg4yoLhTyD~B)M ze<@uz_^idi-T(eebY+yo-pTPBUsdFViwdoNZv-Hc@92)n75a!0OTlva);8Q0p2QJM6 z>B?EYzqqYB{_VMnR9fm>AD`zz7}iZMAss{8Qj$y^Q$pcwL}xKdJ3j;+!w&JMQv7>q za~5RAzn#JgDcFu5k!Oeo7s{q8^PhR1OPy0nP)w-3glH|3ONha8w(DFN3@y@WG`xb>q=znMl_~%)Eh2@_kzDl>C@N=!_&!=$U zl}MZfl?S*_iY{pT^NR;18iY@PE4W^C{L1+drUFr)ut_&LIo&ia1Fm z)~fQDF%k$ulyAOX`h))CL=_`fE>f`Vfk&X@RKaRofUqv<)112q&P*E zkZdp1IFoWW7Jdg=stGDzlx~7f6e67hYEM-%Cayb)pHVr(6^IgX?_|F2EZ$ITQ}}7( zW7(78nJ%J_Dh9&qDj!aWZkFF&`URAu=`&_sQ+-XfD2<&WZl}~2Q_4u29j>?dA!gUp@Pw_*Di$STl_=gm9^^XGR`q7%M*UJ;}Z>RVL)D416U4MY& zAM$L+SML|Gu6LffZzbD=n~q0b+;seFq^A9Je2I(~T*sr;x#@V|=sF&v3LUR})yetk zc$|wm3-=S|NE+W=%MHS;>LX^k$*vl#|9TIYau57V9mi-qgDq> z;q2DLdJg~Qb-hOTpXTw;UpGu91RamOARovB_y_Ocn>hime0?asuH*AXUwPIHW!i$; z(bcnPtlG?a0(s#6*31v&!c9-$-LjK!J2v!$)m=NYo`s%xt!lUw==N)NK8ev!>A*AO z{fPH=N`IspvWt5TTqe^PXkkD1$y_P$?7via(evnfa2(9fx$>(;Se~P1bblqd5n?A^ zN_26KJmK|VH^cOQHPo)vEty}I5pj$4{bc^1@LAR`- z_!BA1AXB%DpfKnbJH8r2v2JmH|0;VO^G$bu9kYpeNQ&S(#%msleqYxy7&=17piF|y zBjYXS$n`4B{V_(vSgi$(%JAk{0oC^QUE9*>IW6OuTW;=8pyZalr2NqZY92Ik&%-Lf z_}yeZ&%qp@?+=#`y#rp559C4TpLuR9ucqGNaz4`a4z-Q?`3c@3{xL0mV9sIAPtX_W z1j#v;=O^!3ilA=4lG;zLdk*)Kw3qG zp;i$zaO2WT@8Gd4^-gJdY5(t(O|GfxS5<23o!(^`dZ!=ho#RQ8E3dh3>a?kqv#+PL z@GkMy)2{1t#pD^YtIw{UTT7}cDSjpA-AU?M(MR$;Xj1@PHAd4_*q2}jUA3L!7w1u$ zM5eBaQy6rW9X}%94`p42HQ&tlLbKOZ4Xt^i-kL&JVL+qLhafM0^P!q;Nx5gE>niA_ zE0-!sTYQ`H>k=*G#ih&WrT(MHK`$XM$OrP!6#VOYsgTw&TaxTwOCpY9O453osuQ&; zdN|k9z)!aGB-k_cg$u3~!tj!u}e)!^(KN`2#p#%%8~t z=Qk+dy1ptgz`WMk__4<7tM)WcI+5l{S|2`JSq*@GvFAhY1kf?x)pQJYqu4>md`9v2 z(^w8<>X^M01|4I^j|jwP9g}I#;MmnK(-S-7`6N@n46zDxWgm4hs7U$MXR7@Y>+d7p zgML9?kPqacDfn+lzd$i3X~qgYbF}G~yGXy}RfhTng1!ttKNj2hbM3&><~0#KbG4D?p|W z*+5~?A$I(@JlFq^a)kivNo;q?)*XO$JCC9EQq(>*&SSv&?bWFMr19%$z|q&yRJuLk zQTnCQ_nVu@2j~a7gB|83C-+(}Z`psd?P*Wp3HJHfBi)DYKpsHg9h7UHb={F`-GKVl zWg5Jj_j-P^oqJ59$cqMN>IS63X|tc}wKCu_@65NJH?M1slk2_wzw}q&rqcO zu62Ly%f+0e^#5u0iH>`Ij{Ui}sQ8YDj({61)%dxsdV%{qsOtt3)4Vrf8awyUbwd&L z?daiTFK5`fFQIUp+q+cL4Z7ZfZa9tN({{5YQ#UN4aOeg*euR1wIzNa&a@fna?Z(;q z0ez&Keo*JDn(n-w(m&qk^}sXE>!FIVcBSr1<-MPN7&BIkp-G+84`{DwvCt2P>h=Vb zu|vhrHXihYpUVZmx_HmCF;rgfA@V~l_H=k~Z=UnReo&j|HI8DbVHD;mX&k3O8?f5tk zXX|*U4Oc$HTqtKsheOAEouxnMXR!6}j)nv!GisBBK*u95$OrOZ@(+F+%WDuF&zbYn z@%&6~&g83_RXSc>hdTbq*YRjRtSea_*vEgGj;}xS0z2?$PxjaGhzrW4jt5`BWXF8# zVP4l9C)Yaue(UVy-~LUdy!^~AGARz{bWQ&=i&6IH#B|Qhr-R>HuYUxO;PE8$&-|H> zaejmHt?T&vjI2V3__^3?l#0*t3X? z(^wz+AG{zRI5(;D&pbDlS6%<(yuLg)N#%UBotrFL;I2c^J?M0->kvL)$ma<8o_#Nw z{KD!-*&kH@Mu=C8<_%~5nLjgi&Tmk@bsb`2IakTee{o(hbL}mg_qw$6`r5h4Ugo(; z>e*m~cOmYs25yb&$FLXx^Jh zjnzTCA9+BYCDHrt@ZDduC*Cg%-~BZu&--5Qzr%Nb)jm8*OP_!E_2bqMTo!OH`f(kv zzSgWo2*@|2+fvMU z-CZ|b67FZX=#p?h!@aQt40Y8d;eN(pn}fJkTO)J{>lXH1@hOn^3D^(1FW`lj>u~0u z`7`lZcLwEK*Ci&_vACbHnC311XW*UlmhcR`y{2W#N6`CRoGA~QR*>h8rZey#RH__> zXW;P#QS58}{n@OA1n|0^k_P)1D%Iy}RkDc4>h`kc?}JvELSo?*wiP<2W+Aws+IEEnuU4+qrI z;Td+T&~zQmXTAAMcX)=KCClmSI{I*)Vc$YJIz_LDfz16s^$i&3JQ|jadH)ag5W{c4 zgx`R1O1A%9u5>lq1GQW$*bn+G6%)t2Z)k36KJRtU{4;;%bDZCxeCxW}#KLiSKbNcd zw6YuN)WxCQNZW=!&e{*LDk8KS=_iruKV1*I*(F9_6xxkE{AV~_Ych-dQ?{?jv?GsqV198QQ0}OP9yYc8I!y zuG03->euB$`}Fqr9_Lzx#`fB0Soa)m-DY^)zp@{+Kg|GYq5$Tf`7@K@{08M)*8?R6 zSX1kPAol5p5)-iGWWQ@0p>w3R4k(o0D4AQ^>pT4``}XfA`+sC3o9{K6{l6Lu4wUoP zBz;FVm;HZ|EIMFKQMUz*d0;l*DS5op8&_=I={!q``2gNkfE(Xe`9D&g*mO@1>+0z6 zpa+l_4Ki_&zS)eJPF${m3xq!Z#%GY_~1QAKWUZgT^ znn!QYtNS(%WmI92ClAK6@E{6^gJ<7&dbIkbSO1#hr0j<7mq>*9m;uWsyygA6l-ev zR3}nKsJwD*&%&(={AwoKxzhpQ&1|0%(tF5uWK%oTlg`Qv}(_vlzpS${&Ri8?ujt_{$!E^oI74P>#?q1Fi41u)nl_7x}#w_VL`&;GkcS2M~A%<(h9@zvNn< zaDT4ztoO5eIIg*0Hp3CeZ7psZg@@m3QKi*-fI4^i`ue^@Wp7~JFE+l{@>An`Eph8P z_DdgA@y$9o-1iOHF52oRSQ_)XJ~1)Pdo7y0%+;O@+efnd?$ACG#%F9F>Cts9X^UG70qG$P4m;Jb-`j4!)TO@XFVR;_Ll)XdmhD@2$IbLvdBJLF^-KuNp1|`o%Rn zpFDx0^&WVJyubLpozfrKQDLn(aGAUqXkkD9$y_P$>_^*N^gQ}A_4Pd!$L-gZU+ux= zIci4tSE}Ci&2#WZPNo|+Yqv~k;x&!8kJSA=tp0mDuYMe5k>xk)t4qsk%FC+z_U>0* zW7}FS?UnJ3dVMZ&%98vB?IY>B0Ts{t@u7Vr*pcooX3{c~myPb_FR8kReQUV>dmmN- z#xL8u=HSNKy=I)o`p_HT1^GZ8bpDy=#`0?FjnF=lsx|ZhOwDOm&sAo!&>L*~fo(j5 z_K{pm^zYI>lCDc2Qf|5={N6)Xv3=LJbb3z9IM$H3e_i}LB}c4F*8lkE)FsFV@}TqI zq`D-uk5sQmpihowUBbGBefORf+5q{IDKy7WqaWQ3((K@!mlgUL!o`7&_2?~a`nt9h0x2| zzEWr($toV*_JXs-g5Tw6*)Su)rozogD9ZqSU&)Nx5YLSr3-H>an+^``AKCj#q5UIM zGQIDE=wOcRr-S*K+}KnIzv26aI$n9q+f)d@;cLHV71}?-NUdR~>)^v>|A_4y>GR;w zzES3TREf2!PG^i%qoeZ8*UJhX^dBes4wp`CSPYu=3GCG&FUSY-VDg^}esiUZI}KGu zlN((e+Bf=p(Z!3X1AAtC=DGd1@s0~Qv}7iXwnO_yvRE8HY&VGgpmu^BATBq)ou$k3 zUO~sQeIs2LhxUy^`$k@EprLSG4~O=Rls=IC&+4d1U83IKob40*0^u7(hX1T@Vp=3B@M@_{@w1^*58^C+;R)wV)tzsO!! zn`?xu6YI?oF-`5r+* z#gtd@4ZBFuWU3Br2V=DPv?QIR|KP*=>9iRLPl}X`lPAB;f_4bIGN1`ET*IP5QENXD z@kC+oKLbnoaro)u2(x{f4W zXrCH%rA$w&H^Rjk9EnS2TqUmb3Aar;?f%WN%U)s zMazTRE>o6u5mPzDA4~BcBD;PdvyJYhb^$w>=#Q3D8_lN&&_@4}$`6j)CTtzDOOhR6 z>?pzJG~B9afh-%kteGd<$DefLr@ueWka2GtPmuF> zM-Be)jL*>C;{xYu*tWWxoL@nm@5#3v8|QKC7Os^pnmW1AUXBn)y1ktLaglS3W!!8G zlun1$7VJ$%1lt?&l6UIm>-+T@Y7ajqGsbv_Yd`4?$V>$h+6k_8!uaA?K7YpVV25@- zsN#K`-mjZ|Ogo==_{*DI9DBrrgn^=vpMc_7$!Q9X7y?)5~n6Y9EhU&VUlZw#C>(ssy zQn%kp1FXTcknYy6BM;ne;pehn2OeW1ouhfZ4Q1ODuBmVv%d4N9H^j4Fzm7R;CCyp4 z(tH(U&RN~s0oE$G9q4NlXb0*|Mc;N%KfVdyb+hNK;k#~n&*a@&^mdTTcir5^H&{F4 z@r~PB8RT8P4dj$}%%9!nui^V7w!HIu7ySKbzGvS{0{A@=_QUr{yh_S{JinimhI1`4 zBG+FdMuf40oi^jH{%C)n=Ei<|u;Dk}Y}wb#IlT5R z0YBOIj-~$bThl3~NBG~*8_>@^nP(di<#0Igy`1=7Mr*4e zlkcGv#OI#mnTnJ;_f+f{{Y%d242gXfhtE36vnkXUWZ+b&eQV%!kENpfM6I|#vhlnF zl^f;(XY(Q|Q+oIJ!X546W%PYV;Gm>4aXQn^9eA{H7S4Zf!ddN$ehD17g^PuFaQ*Ta z<8-F5OdNFvOUJqDom+c$Uc2)V;D8qpJ~P5N==(BpQU{rzx)f3u;<>HQ3|evbYMC$0 z!Qimh4)QLag|ce}KL-nGDv7#LE~=OF2s%dv0?tDEe>9P!zA91&(M1D?`N?ZJCtbH~ z*LEETd!Zo74?Uj{ICbWhzlD;OdcG)*S^LuD~-@BAn6AvC9?#-i#pMLK zU(3oT-25+YlluLSdrVALidz>bCfwJ@YniEX1LQJ?>3QTuNe+V6at@1pp9%mg#jObH zRrNcos=HE7`Bvk&OnD5({R^MKS@%{e0jx85-paiZm&)qiY6(|5acgmG6W5EJw%hHs zdR}X1yX|K3HweNy`ODuD*iHDBr}*sa#GU$1F!Y>h81VV&w{~~g(OIc1h`G05_7f&K f_sYz1G#I&8ez-qyGP!eNvTS1L^qv;~15NP*ju)>x literal 0 HcmV?d00001 diff --git a/pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr_v6_dump.pcap b/pkg/xtcpnl/testdata/7_1_8/netlink_route_getaddr_v6_dump.pcap new file mode 100644 index 0000000000000000000000000000000000000000..a16da086ed41e623ef913ec2002d88d20f23d36f GIT binary patch literal 1212 zcmbW1&npCB7{|Z!W7)w$ta7l2O`MbiNmlGhinM!?n@Exz{J1!%ou)m=8OcR{lp+or zIp81{w_Sxe$-%|nU}rqf*f;OYEN!0YJJUPw`+nZ<`#kT=!)C+)|*b6Hj1_TFMDL-aG?8`QJb>RFi+qb>7@9sM%A%NxjAw~$*?)t%eTdozZo9m0_ z6vN|dggmkS^2NuEIX++a|MHcz$a^tg!qNBBb1v%)U}*7gUxFii9gI#oc67~`S+J6tpuxmMO?<@|-MBC&rheafbWU&Ylo>LZmh^A${m;4goc}!T z`ToZ_bMy1d7po*81xm=j$eiE){tG|sUnps$c}XI!7?Y%JxRyvPegWl}U(B0BzSK(% z@|3fvd!Y#a)fJMnE-q3hRYE!6U5uenBF_60!n;Vd#AR?;#FzWzSCsWon&g=lJ?T~@ zeKm#{%C)HXzO)*?*6{U)KV*1=skcogCMbV9p0j?J;g1-;&+t9+_e3?`?=|K3<2ma! zDmk8PF!DB<=erC~DV~%AhCimbCtDS-Rkc)7YB3L%0(k&q)cHV?GBkYhboO*suEy5L z8+iU2>ggHMHJEmDrOGY^ZU zZJqod9X6>)HJNh~1}vW3?FiY8?k>*h>F&7_6h;#8l>BPsk9(jveiNwbjSmM4E$48^8S2{lUm7?%LIW9if zdtY{``Ss=Y`1t-{_s`q@6on7Yx5n#oND*;yQY#%|%T@z3Cr(O5@S++D-NN78eQnpB z`;2MUiNecKESJ@HV9ML6;RUt|2%jfsiTnuISJe+gMJ4TDz3Y{y_7many0{g|i=a1ChZT$@D< zavi$YY{wwFJDu(jgA`OI22*XR&fTqj{h4$oRls0N>og3efx(5C*`Cv51A_xSxwB|% z8CK|t!LjzEeZ#rz&g`k!Y$*$9f$|7As*xv zjw^peg|N>{Z#oWTO`^|xW+2y_gFSNbOuOd#ywulGKCiZ~#eH5~uXH<1%Mj)BQV#7f z$(N1Fe$Wot2g3!Cb_oH#d-ZJ}dG`tO_`S z0U~uvfh?89$8?Ty+jS&;XjjeSGLFgSyroW)d#0c8a`GIHj%$)CvZveyc&vLGprGZICxH&!j*a z<=sA;-XJ%z7D<8JKN%+n_~z|;8qkkT>b)nM4Tm!bs&rhhgobXMuVQ5V{qTF%apDww zEgjdtg=NrvFk07AhHZtMtx|j>8*@bI zIPMNu9Tz~yWrq7+%tFZ(Fhs4$HNBY4ffx3@!f}12b=>Xtz1Sb>IHHX@j?11{Ci-X6 zaUVY2TR(~q$9*rZ7xudp9S5Ws~@W0>ivU={Vg}t>bihUdQoU z&2Ak>onUnZzp+bv=jgb}IIyOpN_IlGN5z4x&wBRaik;1SG3@U&`k!>%?`S9N$MHPC z#%If*<9c&Vtv&7OmUM4RXGd$#6kP{2&PrX!Z%m38x?UZ-JG$#Lm{AV@!J(G3^-QSzh6o_5k)2 z!@7{Cj8+#eVoaND8tU(DIx{jveNz7Z^6h*+MnrdGe_89l!dVXW<4iu^koVQ$LkNS4 z`FwSVRcl~j&tU5hqR{8f%HA>-Wm|J3W}5UT-agqDPxeG(%=!_Q&-)Yn;#0|DEb1(D z4~kk0(VrlOhI5(0p0nAJ1DU3K8b|#%{7W_8l!qgY)wzkIkAb5nUzx{|i;i+^)jFJ! zF2@;y4?`KCEl67GO5*p6sERhqm=^S(30`jcTlM zWyd^}Cjk^d$C?bRNIrf&>ry!Xyv7eVW%Rp2WVV&Nmvq(eO=%Z!mnT;oA(?JJEqTC+5Qd zXT_ERS!t7KbG7ONZ9ON)$9XeJ|0avv?%!_43S@q6>aa|%E&k4P^Eym@TyrZ&hgm(f zYMMWtj$eelPt_{YXGBATCx(YYXGCn$-9KfXI_fHXcAhm58BxC*BtEF4NIvkO^OZXz z((*K}+%qD!SIn1o_etq9^LK=5%&0TheB?#Tk0*YCw;$ef<9FfQxL2ipWXj__lk8q0 k+p|oy9Oo4lg&on7E`{*@RZ_7Ib`@_ihHs{@oLpdC8ZjA zuoTE{JfqGBl9Zw0(_`7OtXzw&lQ&TQ8ro?M=@v}8|AHhdvA}J;LWyqc=G}A+hDzOs ziE>i0YUqF|$=6}T)a4*D7rJ$uzc5zbJ%~Shv3*-U33_jtuB*oUL51Xx#_-lfo<)Iv z+tZ)z#BWMiq*BxHT~yYn8HH_~ZfJ#>A}~lar%W312k+60&Lr2CasCU%O`YLs1vu8gQL+*DPX?^U(dzcMM{?M<+|niw6w=jKCSi*i~F>?UFqvA zEq|0xOF3L;Nxp1R>jT$WolmL!Z0qc?r{owEGR>!Tec3N!%b|;y^yUUK&u2wGiB$l{ zHHZo|1t$JwE|BG>l<5^xdqQU!mt9BFhxODvE)!5T^_ChV_slrq#pL-sI&Miyl@btO z1bNXT4KPxhPNEkQ-w(+%F^wk(w?%tcZl_fN&a0p5ALRs+VdRo(Ywo8fTwKyw|pE1{ta^;L|l zKOer&HclLZx25Cuw=fO54@cWl%CLQr&!rDUc~&<2vEz2jiltef6pll5Y3Q2J`EuhB zwkpL3vN1)Jjbrq0ZCn5wml^JRF$*JCz!0q>=X5Q*1261rh2!?QwsFN`3F_RnaYP$! z9H%|8O!UuY<34=4cjG98a9@k_h2t*8#zCy2*=(GxLmQ{{Q{2X}ZW2EjFg#C`jngC5 zHcqD(Z5-d#{I+qNpVn6J9lOMPj*Xj&^Qt;3qzSe?D$ZkjwzGfE*!jHI!tu_a|H;Pv zj();^9K8k`f7QXp_2wE|d)m`2>E4#kj@F)Owhm~Vm$r`Yp8g!wNLxpnT*|)5%M(9! zy*hq(Y~4$bV-RW_b7AZBNVTog=|x+2Z`!&G0OXZt7HyqIkG_@@8(V+w5cUMawvMNS z*48a!%$jW+>hEnlJ2FIjQU3n$?R+{$Ja=P%SlhS4Sq$ypY(CwP_w~^u2y=@0bTx=Y ztFVHe#nv4)?jt7BHdUWyE|8dL%3pZx6OAE0m-}Dz7x>1flf_WfS>`@ewHTtm zKnxA%GJ`$mvLlBwjrTN;`fvD`tG+D{M;faO6GtBdM^C=8h$9yr<*Y>;aK^b3XPgd3 za(cDld5AvC{3yaF-|t|oMq%vC$>zPCJsq8Cg)feW-_(Ttah8{|zp8Ef0b}FqWiHn# zAFB*w3imv--1X{m{mtXozbTHhLF}`->(vry)9$$*iFxQ-e~XetB+#IA5;yxa3H8jZ zLGqLa$@Tt%hrLH#uD_1)R4=^0-n83fc(tjgHxmQ+4tcRY`qHU%5__w$JlAHuQJ%y; zk0nU0Y1+v;EA#<%7 z1J`;g$H#dwNq0xkVeMUaq;6W5cYSS~J6+PRB1n-lu97 z=`*0A!BfLSp)(+M>F$p*PaAa&pH%TIfyjvZ?k}dw@BF(zdU>;*0crUfSMC`Q$5+gk zcK1Q)GxIw@^~`9q(0t@&D^DhVfwv#tQ{#J~ZruM|`^c0>J(KKSAp5gaEN$=4r*i{Z MZmuqcZ(&9L0~pc5&fUH6;;G|xA}*#OE++ACcg{;pUkauO#* zTH*$Avbp08S2)Bm7k$P0x8W+_u@XG$COtf2qNynko(;rxq^*xc>u6d>(sGo#ymDJ1 zw?07bppZ0uQD}w~%|}4v>!W4C?L(hHM{i$+^ii|o0c7=aOq^WAXY}(TA^X?Gdtd)* zTD&TxU94#rE84~&TCKZR?%C%am2!cl+=d|9Rw43rIS#p$o0nLQEBd#@xJued4!M`M zp*-3kxtt4>J3S|SeHAL#(Q-@C2FM*`|3a?Balv^NEH{95NYhFj7o1-{S`2znKOdHT z*C2r97}3Cdw5_4EQs>gN{xLe7&*$0R(zO2eDt}@8Mu;s)o&9n_E9EL4#b^WMO8Y5c zM_R72g*^Jxh3h-HNVT`94TkjdNojkKTg(Q-+PhfGElKNdud>?)QQCed>%Hv-jqGQe zc0c;U_UTRi@K=q6>p}}2*Vkw3-W3m`wt{K@r^aioNSarn*by!AoloWt`bZHo`f@Fz zOs>f`P$o6wnnHhBk<5N2ll;y4CuKH^W;-;nWzwnDOr}Fk6xcGk{?$TeE~|xUWXr5o zJB!J@67A%=S&hE+&f8+`tkt|NCbO?f?c`LkZKaq@u6Nbw+bA-*MqW0Vn6M@;u1F?y z_WE1eVjATwh`&uAzteLxpX>hG{HQV+JNW!E(EGJ*4mR0OAPvTL5M9ZAIW^+&5^i)!G&Bq=Pmv>KF?!5NsR4}hA_Qz_D`THR# zj?n#3@%pM{`sUbVp-k+VrtP;%GK1Ucja_s*S-BRrB-=SHv!I<-lId%w@xy461iNpm zc|!l#=<1Ewf6t5-Kx&-p%KpZ~UVzvr6L`Ds#knHJ`g@$2wbPmF8`z z%tI3w^SQpq4%srRW=Sz=R_@Hv{0Fs)*Q~~esOrE z-M1CnC!8nt7IJmwUeW9=h;5KEbuOo3`<#KyitTd-GC2?x`S=;gtk_nxOq1g%XFNf2 z+1pvMADThmR_t$QATz3cau2l>d#JT?Oz`75(_}`r9;pCxE{I2Y4tfh{c=#y~Ks_`Y zP>$5Kq+xx6bTaA|`}>uG^NzB6!Dl}VoR?R28fBbUl>OfWOP*nJmwdK0t6ao9XqFk> z+diIR&S1Xy8|pit;I76II6#wlo5ajfya})4iVk^>=Za48@|}FXUcbLVTd)qr3{vkvYT8|?b0Qp=a-zUYbXshboCeb}rw*j0U-Y3M_*mdHoc>g5$ zP`&})+m}5)rcNWSz&KH8IPyE2UvMBI}?+qBe?Xs|YLz8{K+uTmcoGLIk zGU~>wook7j9uJ0se%J+!the-3=k;UzDxEuTgi$A-52-tm7O z;RvysvE@a|mOHnMr-oCbd$q37ZTdg!X&d1-eHJpK*z||_2GsZ4G>*?Pd#7!hQ`Hr1 zvQ4f?NsBCI)A7b}>_Q4{xdSDk^bcNJ=X|%XtKHV2t{-M->tqzs)>B=n-mRTO!|9%MYTDL2I(@d@16yB!o*g)F zX!pqOfw4y*s|7Rk;gLgIb`9+r%WTff z{^1Xwz4#($0{H~_hjy&_WImHMe^&X2R|5P4S{}(ifX8g}4@(}O^AFN^^bcbJ!p!|c zyVpNx`%$q#dH$hY`Ul#i@(;966+dJn`UghP25kTEB>3#ay1>gDKWs-C))5&$IB&Im zgZ_bhjDJ`NpLH;^X>@pS)4{!?GxH59t`3hKxaQX)c3>RK*nw*wV+Z15vBRkIDza>a zzQK+Snz8%hCprh=*1-xq*J<8rr;r5q(LMVPWDaCz#s1*i`?~5A19LusV`(6YPq1VC zXCm4vceMs=TYVOM%GtLc>(9STTO}W3t1a4A_l%`S1|G@m-JafrIT}6IpDp$}eBMPS zKAOEMpD;V^^(U~`PknLDUX9%lN3qux*w0^s{XEw*Z6jl9Rbxy(y>I_nL|ax-gwo2k zyQD)ZN6UW~BHEo%EcE>lry!~Gk$g&GeKwF3OUy0wis>9>oj8Y5##s|c4Ka6_IzY@U1NB6PGt2g< zyir1CQ^|K8ij}5GWDCuGLbj6hW_(mm$-(&xp$WUeSoXK_J}EX!yb8aJMF_5t;UaK{ zd`{r*aoi=4qg4IM+$iV~_xnC_VD78`N#;H7H5@Wtae}e2Fk|sEaixfuE z2yi9iBKD)nKT2h+AHEC9n>KdWiOpztP%ee!q%+rCE`>c(2(~Z%T|{5X^9uvEFP#9N zOK~ADuP^;O$~oVe1O4}(&LG1Qla_18MT29TItRA&bo2~%^mca+z$T2%`p-2uwn66_ zm)oZ*J=VZWQJ*$#!=-bek4{{~$$f2n>Rq2uqf;H9sx(zTRo&0|RQk*RKcD&p4Exll z=X|QN9`zd~cC~%#n-P7geF|p#)Qe@tr*Eu1_IvtN@-gu#&xjB19veh>Dt#%}N}ds4 zsrZ!o1)V3+huZO}@~Lfd0LsY;-MdrVO9yP95!*STu=sSV8e-V;B7H}@E{sp#en7pV zFI91AczjB|i^r!*Q{_w5{hTko`h6*9K$-C=b`$Dc|6ACmY`eR-FC|~jnQF$T!rnag$=?@1H1M;t-<6WjbYND3p{;A+|+bs|4v zg3;Sitn>T)oXTY|>HQ;j^dh_zy;BzQ5Hu$BxT4cVB ze9RuPnehzHb=tS~4s`eS$e4yQqI~z}-5+usTyeXc4=(a5)ja2NVM*L8+crtdigMod z{HhDP&b<~M+l(OhW}kP>Lm*`Ga64iSWUFtD60qr3DVtw3QYZCyi>yI#m{*fnMWPP! zQR-QJi{(futarWaD+l=~_ML+^s(LEHl*FDrE6kp8!PI>M`LjDJobpZT>U z`KVl=`8#+A-$@b@7!!gcwI^PqpVw-@~ literal 0 HcmV?d00001 diff --git a/pkg/xtcpnl/testdata/7_1_8/netlink_route_getroute_dump.pcap b/pkg/xtcpnl/testdata/7_1_8/netlink_route_getroute_dump.pcap new file mode 100644 index 0000000000000000000000000000000000000000..b973c3ad522ce2910cedbec6fd61dd49595663ff GIT binary patch literal 7204 zcmc(k&ui2`6vtn7H{IQ$xUD@Dv`~M7AP6E-R?!~(1L{S*+V&vDTRjvh>|$?Tyowj8 z3W_WqisD64@Zzl%R1^>5K@a{7-Ng6aBa1_=~Jzjdh?m-35gBEynPXi7>z~cxk@>qvn>+H`4 z_%wPAnxxzot4YPj>jnsyP* zg3w$*jpCz8y?y8toMYNo1|PM=GjNdn>_Kmg&e6|f!2WIEb;ZAt7B3~Wl~}S9-2SyAWx4tO2brMTB(xh@(*s}-QpP3 zKM}9vurI!39DSJJYYKCYY9x5^e5n@^Q|@adBqq&_dJ5G`E9R_Visy>{$IKSA94^l2vIkeSr~%3ucF2o?=8vn)Han0sL-^-UMPO|RQ5JIh+PSzSxS1b57S=%Ed+eeggO3v5)`GtcAh(`}>PBY44!a+b-=L zcuUXmq<%>8OdYt7zv}7gs-3!h zLS(0P|1{Z|Wa2x~AU_>3^>(KBCXt{%Wf~oY+*ta9idA8+-!uwi{=lR=_sB?<}Lqg7+jq@Au}DVTO)I2>rWW8S65`Fqnco3 zKD{;{22;yr>=TU4*Pk{nJ$&$_j6IlP6N@LlJ8*ZVcft7GfkydY zX7pQ)b$$-Pw9d~Vm=p-B8b1WnI#(iQ{2Rtj;)#-7x6`@~4dGksdOHNOXnxW!s#ScI KkN?-B9Q+SzFs$DI literal 0 HcmV?d00001 diff --git a/pkg/xtcpnl/testdata/7_1_8/uname b/pkg/xtcpnl/testdata/7_1_8/uname new file mode 100644 index 0000000..11fad7e --- /dev/null +++ b/pkg/xtcpnl/testdata/7_1_8/uname @@ -0,0 +1 @@ +Linux l 7.1.8 #1-NixOS SMP PREEMPT_DYNAMIC Sun Aug 9 18:26:58 UTC 2026 x86_64 GNU/Linux diff --git a/pkg/xtcpnl/testdata_test.go b/pkg/xtcpnl/testdata_test.go index 1343a11..ed3bf2f 100644 --- a/pkg/xtcpnl/testdata_test.go +++ b/pkg/xtcpnl/testdata_test.go @@ -25,6 +25,12 @@ const ( tnMeminfo4_19_319 = "4_19_319_attribute_meminfo" tnSport26546V4 = "7_0_3 sport26546 dport443" tnSport19000V6 = "7_0_3 sport19000 dport10156 v6" + + // 7.1.8 rtnetlink dump fixtures. + tnGetLinkDump = "7_1_8 getlink dump" + tnGetAddrV4Dump = "7_1_8 getaddr v4 dump" + tnGetAddrV6Dump = "7_1_8 getaddr v6 dump" + tnGetRouteDump = "7_1_8 getroute dump" ) // Testdata file paths. Grouped by kernel-version subdirectory so a new @@ -70,6 +76,23 @@ const ( tdResp26546_7_0_3 = tdBase + "/7_0_3/netlink_sock_diag_response_7_0_3_sport26546_dport443.pcap" tdResp19000V6_7_0_3 = tdBase + "/7_0_3/netlink_sock_diag_response_7_0_3_sport19000_dport10156_v6.pcap" + // 7.1.8 rtnetlink captures (nlmon, NETLINK_ROUTE only). + // + // The three *bulk* pcaps are raw per-type nlmon captures produced by + // `nix run .#capture-netlink-fixtures`; they contain our RTM_GET* dump plus + // whatever other NETLINK_ROUTE traffic the namespace was doing. The + // generator (xtcpnl_extract_7_1_8_fixtures_test.go) isolates our dump by + // (nlmsg_seq, nlmsg_pid) and writes the clean single-record *_dump.pcap + // fixtures the deserialize tests read. + tdRouteBulkGetLink_7_1_8 = tdBase + "/7_1_8/netlink_route_getlink.pcap" + tdRouteBulkGetAddr_7_1_8 = tdBase + "/7_1_8/netlink_route_getaddr.pcap" + tdRouteBulkGetRoute_7_1_8 = tdBase + "/7_1_8/netlink_route_getroute.pcap" + + tdRouteGetLinkDump_7_1_8 = tdBase + "/7_1_8/netlink_route_getlink_dump.pcap" + tdRouteGetAddrV4Dump_7_1_8 = tdBase + "/7_1_8/netlink_route_getaddr_v4_dump.pcap" + tdRouteGetAddrV6Dump_7_1_8 = tdBase + "/7_1_8/netlink_route_getaddr_v6_dump.pcap" + tdRouteGetRouteDump_7_1_8 = tdBase + "/7_1_8/netlink_route_getroute_dump.pcap" + // Bare testdata/ (no kernel subdir — placeholder fixtures) tdAttrPragueinfoFake = tdBase + "/attribute_pragueinfo_fake_fixme" ) diff --git a/pkg/xtcpnl/xtcpnl_extract_7_1_8_fixtures_test.go b/pkg/xtcpnl/xtcpnl_extract_7_1_8_fixtures_test.go new file mode 100644 index 0000000..fd0b4f5 --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_extract_7_1_8_fixtures_test.go @@ -0,0 +1,340 @@ +package xtcpnl + +import ( + "encoding/binary" + "os" + "path/filepath" + "testing" + + "golang.org/x/sys/unix" +) + +// TestExtract7_1_8_Fixtures turns the three raw nlmon captures under +// testdata/7_1_8/ (produced by `nix run .#capture-netlink-fixtures`) into clean, +// single-record "dump" pcaps the rtnetlink deserialize tests read. +// +// Why a generator: nlmon mirrors EVERY NETLINK_ROUTE datagram in the namespace, +// so a raw capture interleaves our RTM_GET* dump with unrelated route traffic +// (neighbour dumps, per-ifindex link lookups the `ip` tool issues, etc.), and +// nlmsg_seq collides across sockets. Our dump is the set of messages sharing one +// (nlmsg_seq, nlmsg_pid) that forms a run of RTM_NEW* of one family terminated by +// NLMSG_DONE. This test isolates that run and re-emits it as one pcap record +// (cooked header + the concatenated messages), so the fixture is deterministic +// and small while every byte remains real kernel output. +// +// It emits (via writeIfChanged, so `git status` stays clean across runs): +// - netlink_route_getlink_dump.pcap RTM_NEWLINK dump + NLMSG_DONE +// - netlink_route_getaddr_v4_dump.pcap RTM_NEWADDR (AF_INET) dump + DONE +// - netlink_route_getaddr_v6_dump.pcap RTM_NEWADDR (AF_INET6) dump + DONE +// - netlink_route_getroute_dump.pcap RTM_NEWROUTE dump + NLMSG_DONE +// +// The test fails if any target dump cannot be reconstructed, so a +// renamed/missing/short bulk capture is caught immediately. +// +// go test ./pkg/xtcpnl/ -run TestExtract7_1_8_Fixtures +func TestExtract7_1_8_Fixtures(t *testing.T) { + const outDir = "./testdata/7_1_8" + + type spec struct { + description string + bulk string + out string + newType uint16 + wantFamily int // -1 = any; else match the RTM_NEW* body's family byte + minMsgs int // minimum RTM_NEW* messages expected (sanity floor) + } + specs := []spec{ + { + description: tnGetLinkDump, + bulk: tdRouteBulkGetLink_7_1_8, + out: tdRouteGetLinkDump_7_1_8, + newType: uint16(unix.RTM_NEWLINK), + wantFamily: -1, + minMsgs: 2, // at least lo + one real NIC + }, + { + description: tnGetAddrV4Dump, + bulk: tdRouteBulkGetAddr_7_1_8, + out: tdRouteGetAddrV4Dump_7_1_8, + newType: uint16(unix.RTM_NEWADDR), + wantFamily: unix.AF_INET, + minMsgs: 2, // 127.0.0.1 + at least one global v4 + }, + { + description: tnGetAddrV6Dump, + bulk: tdRouteBulkGetAddr_7_1_8, + out: tdRouteGetAddrV6Dump_7_1_8, + newType: uint16(unix.RTM_NEWADDR), + wantFamily: unix.AF_INET6, + minMsgs: 2, // ::1 + at least one global/ULA v6 + }, + { + description: tnGetRouteDump, + bulk: tdRouteBulkGetRoute_7_1_8, + out: tdRouteGetRouteDump_7_1_8, + newType: uint16(unix.RTM_NEWROUTE), + wantFamily: -1, + minMsgs: 4, + }, + } + + for _, sp := range specs { + t.Run(sp.description, func(t *testing.T) { + bs, err := os.ReadFile(sp.bulk) + if err != nil { + t.Fatalf("ReadFile(%s): %v", sp.bulk, err) + } + msgs := extractDumpMessages(t, bs) + if len(msgs) == 0 { + t.Fatalf("%s: no netlink messages found in bulk capture", sp.bulk) + } + + full, cooked, count, ok := pickDump(msgs, sp.newType, sp.wantFamily) + if !ok { + t.Fatalf("%s: no %s dump (family=%d) terminated by NLMSG_DONE found", + sp.bulk, rtmName(sp.newType), sp.wantFamily) + } + if count < sp.minMsgs { + t.Fatalf("%s: dump has %d %s messages, want >= %d", + sp.bulk, count, rtmName(sp.newType), sp.minMsgs) + } + + pcap := buildSingleRecordPcap(bs[:PcapHeaderSizeCst], cooked, full) + + // Re-read our own emitted fixture the way the deserialize tests do, + // as a self-check that the round trip is walkable and ends in DONE. + var sawDone bool + var newCount int + walkDumpPayload(pcap[PcapNetlinkOffsetCst:], func(mt uint16, _ []byte) bool { + if mt == uint16(unix.NLMSG_DONE) { + sawDone = true + return false + } + if mt == sp.newType { + newCount++ + } + return true + }) + if !sawDone { + t.Fatalf("%s: emitted fixture is not terminated by NLMSG_DONE", sp.out) + } + if newCount != count { + t.Fatalf("%s: emitted %d %s messages, extracted %d", sp.out, newCount, rtmName(sp.newType), count) + } + + if werr := writeIfChanged(filepath.Clean(sp.out), pcap); werr != nil { + t.Fatalf("write %s: %v", sp.out, werr) + } + t.Logf("extracted %s: %d %s messages, fixture %d bytes", sp.description, count, rtmName(sp.newType), len(pcap)) + }) + } +} + +// dumpMsg is one netlink message lifted out of a bulk nlmon capture, tagged with +// the (seq,pid) that identifies its dump and the cooked header of the record it +// came from. full is the whole 4-byte-aligned message (nlmsghdr + body); body is +// the bytes after the 16-byte nlmsghdr. +type dumpMsg struct { + seq uint32 + pid uint32 + mtype uint16 + full []byte + body []byte + cooked []byte +} + +// extractDumpMessages walks a bulk nlmon pcap and returns every netlink message +// in capture order, walking ALL messages within each record (a dump reply packs +// many multipart messages into one datagram) — unlike the single-message +// sock_diag reader in xtcpnl_extract_7_0_3_fixtures_test.go. +func extractDumpMessages(t *testing.T, bs []byte) []dumpMsg { + t.Helper() + if len(bs) < PcapHeaderSizeCst { + t.Fatalf("pcap too small: %d bytes", len(bs)) + } + var ph PcapHeader + if _, err := DeserializePcapHeader(bs[:PcapHeaderSizeCst], &ph); err != nil { + t.Fatalf("DeserializePcapHeader: %v", err) + } + + var out []dumpMsg + off := PcapHeaderSizeCst + for off+PcapRecordHeaderSizeCst <= len(bs) { + var prh PcapRecordHeader + if _, err := DeserializePcapRecordHeader(bs[off:off+PcapRecordHeaderSizeCst], &prh); err != nil { + t.Fatalf("DeserializePcapRecordHeader at off=%d: %v", off, err) + } + dataStart := off + PcapRecordHeaderSizeCst + dataEnd := dataStart + int(prh.CapLen) + if dataEnd > len(bs) { + break + } + off = dataEnd + + if int(prh.CapLen) < NetlinkCookedHeaderSizeCst+NlMsgHdrSizeCst { + continue + } + cooked := bs[dataStart : dataStart+NetlinkCookedHeaderSizeCst] + p := dataStart + NetlinkCookedHeaderSizeCst + for p+NlMsgHdrSizeCst <= dataEnd { + var h NlMsgHdr + if _, err := DeserializeNlMsgHdr(bs[p:p+NlMsgHdrSizeCst], &h); err != nil { + break + } + mlen := int(h.Len) + if mlen < NlMsgHdrSizeCst || p+mlen > dataEnd { + break + } + out = append(out, dumpMsg{ + seq: h.Seq, + pid: h.Pid, + mtype: h.Type, + full: append([]byte(nil), bs[p:p+mlen]...), + body: append([]byte(nil), bs[p+NlMsgHdrSizeCst:p+mlen]...), + cooked: append([]byte(nil), cooked...), + }) + adv := mlen + FourByteAlignPadding(mlen) + if adv <= 0 || p+adv > dataEnd { + break + } + p += adv + } + } + return out +} + +// pickDump selects the (seq,pid) group that forms our dump: a run of newType +// messages (optionally matching wantFamily on the RTM_NEW* body's first byte) +// terminated by NLMSG_DONE. It returns that group's messages in capture order +// (including the trailing DONE), a representative cooked header, and the newType +// count. When several groups qualify (e.g. the v4 and v6 GETADDR dumps in one +// capture), the one with the most newType messages wins. +func pickDump(msgs []dumpMsg, newType uint16, wantFamily int) (full [][]byte, cooked []byte, count int, ok bool) { + type key struct { + seq uint32 + pid uint32 + } + // Preserve first-seen order of groups for deterministic tie-breaking. + order := make([]key, 0) + groups := make(map[key][]dumpMsg) + for _, m := range msgs { + k := key{m.seq, m.pid} + if _, seen := groups[k]; !seen { + order = append(order, k) + } + groups[k] = append(groups[k], m) + } + + best := -1 + var bestKey key + for _, k := range order { + g := groups[k] + var hasDone bool + var n int + var famOK bool + for _, m := range g { + switch m.mtype { + case uint16(unix.NLMSG_DONE): + hasDone = true + case newType: + n++ + if !famOK && len(m.body) > 0 { + if wantFamily < 0 || int(m.body[0]) == wantFamily { + famOK = true + } + } + } + } + if !hasDone || n == 0 || !famOK { + continue + } + if n > best { + best = n + bestKey = k + } + } + if best < 0 { + return nil, nil, 0, false + } + + g := groups[bestKey] + full = make([][]byte, 0, len(g)) + for _, m := range g { + // Keep the dump's RTM_NEW* messages and its terminating DONE; drop any + // stray NOOP/other types that happened to share the (seq,pid). + if m.mtype == newType || m.mtype == uint16(unix.NLMSG_DONE) { + full = append(full, m.full) + } + if cooked == nil { + cooked = m.cooked + } + } + return full, cooked, best, true +} + +// buildSingleRecordPcap wraps a cooked header + the concatenated (already +// 4-byte-aligned) netlink messages into a one-record pcap: the original 24-byte +// global header, a 16-byte record header with zeroed timestamps (for +// determinism), then the packet payload. +func buildSingleRecordPcap(global, cooked []byte, msgs [][]byte) []byte { + payload := make([]byte, 0, len(cooked)+64) + payload = append(payload, cooked...) + for _, m := range msgs { + payload = append(payload, m...) + if pad := FourByteAlignPadding(len(m)); pad > 0 { + payload = append(payload, make([]byte, pad)...) + } + } + + rec := make([]byte, PcapRecordHeaderSizeCst) + // TsSec/TsXsec left zero. + binary.LittleEndian.PutUint32(rec[8:12], uint32(len(payload))) // CapLen + binary.LittleEndian.PutUint32(rec[12:16], uint32(len(payload))) // Len + + out := make([]byte, 0, len(global)+len(rec)+len(payload)) + out = append(out, global...) + out = append(out, rec...) + out = append(out, payload...) + return out +} + +// walkDumpPayload walks the netlink messages in a datagram payload (the bytes +// after the 16-byte cooked header), calling fn with each message type and its +// body (bytes after the nlmsghdr). fn returns false to stop early. It mirrors +// DumpRtnetlink's in-buffer loop and is shared by the extract self-check and the +// deserialize tests. +func walkDumpPayload(data []byte, fn func(mtype uint16, body []byte) bool) { + for len(data) >= NlMsgHdrSizeCst { + var h NlMsgHdr + if _, err := DeserializeNlMsgHdr(data, &h); err != nil { + return + } + mlen := int(h.Len) + if mlen < NlMsgHdrSizeCst || mlen > len(data) { + return + } + if !fn(h.Type, data[NlMsgHdrSizeCst:mlen]) { + return + } + adv := mlen + FourByteAlignPadding(mlen) + if adv <= 0 || adv > len(data) { + return + } + data = data[adv:] + } +} + +// rtmName gives a short label for the RTM_NEW* message types used in test +// diagnostics. +func rtmName(t uint16) string { + switch t { + case uint16(unix.RTM_NEWLINK): + return "RTM_NEWLINK" + case uint16(unix.RTM_NEWADDR): + return "RTM_NEWADDR" + case uint16(unix.RTM_NEWROUTE): + return "RTM_NEWROUTE" + default: + return "RTM_?" + } +} diff --git a/pkg/xtcpnl/xtcpnl_ifaddrmsg.go b/pkg/xtcpnl/xtcpnl_ifaddrmsg.go new file mode 100644 index 0000000..059b556 --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_ifaddrmsg.go @@ -0,0 +1,111 @@ +package xtcpnl + +import ( + "bytes" + "encoding/binary" + "errors" + + "golang.org/x/sys/unix" +) + +// IfAddrmsg mirrors the kernel's `struct ifaddrmsg` — the family header of an +// RTM_*ADDR message. +// +// struct ifaddrmsg { +// __u8 ifa_family; +// __u8 ifa_prefixlen; /* The prefix length */ +// __u8 ifa_flags; /* Flags */ +// __u8 ifa_scope; /* Address scope */ +// __u32 ifa_index; /* Link index */ +// }; +// +// Reference: https://github.com/torvalds/linux/blob/master/include/uapi/linux/if_addr.h +type IfAddrmsg struct { + Family uint8 // 1 + Prefixlen uint8 // 1 + Flags uint8 // 1 + Scope uint8 // 1 + Index uint32 // 4 = 8 ( 8 / 4 = 2 ) +} + +const ( + IfAddrmsgSizeCst = 8 + IfAddrmsgReadCst = IfAddrmsgSizeCst +) + +var ( + ErrIfAddrmsgSmall = errors.New("data too small for IfAddrmsg") +) + +// DeserializeIfAddrmsg does a binary read of an IfAddrmsg with a basic length +// check. +func DeserializeIfAddrmsg(data []byte, m *IfAddrmsg) (n int, err error) { + if len(data) < IfAddrmsgSizeCst { + return 0, ErrIfAddrmsgSmall + } + + m.Family = data[0] + m.Prefixlen = data[1] + m.Flags = data[2] + m.Scope = data[3] + m.Index = binary.LittleEndian.Uint32(data[4:8]) + + return IfAddrmsgReadCst, nil +} + +func DeserializeIfAddrmsgReflection(data []byte, m *IfAddrmsg) (n int, err error) { + reader := bytes.NewReader(data) + + err = binary.Read(reader, binary.LittleEndian, m) + if err != nil { + return 0, err + } + + return IfAddrmsgReadCst, err +} + +// AddrInfo is the subset of an RTM_NEWADDR message xtcp2 keeps. The prefix +// length comes from the ifaddrmsg header (not an attribute). Address/Local hold +// the raw network-order address bytes (4 for IPv4, 16 for IPv6); the caller +// builds a netip.Addr from them. For IPv4 the kernel sends both IFA_LOCAL (the +// local address) and IFA_ADDRESS (the peer, on point-to-point links); when they +// differ, Local is authoritative for "this host's address". +type AddrInfo struct { + Family uint8 + Prefixlen uint8 + Scope uint8 + Index uint32 + Address []byte // IFA_ADDRESS + Local []byte // IFA_LOCAL + Label string // IFA_LABEL +} + +// ParseNewAddr decodes an RTM_NEWADDR message body (the bytes after the +// nlmsghdr): the ifaddrmsg header followed by IFA_* attributes. +func ParseNewAddr(body []byte) (AddrInfo, error) { + var m IfAddrmsg + if _, err := DeserializeIfAddrmsg(body, &m); err != nil { + return AddrInfo{}, err + } + + ai := AddrInfo{ + Family: m.Family, + Prefixlen: m.Prefixlen, + Scope: m.Scope, + Index: m.Index, + } + err := walkRTAttrs(body[IfAddrmsgSizeCst:], func(atype uint16, val []byte) { + switch atype { + case uint16(unix.IFA_ADDRESS): + ai.Address = copyBytes(val) + case uint16(unix.IFA_LOCAL): + ai.Local = copyBytes(val) + case uint16(unix.IFA_LABEL): + ai.Label = string(bytes.TrimRight(val, "\x00")) + } + }) + if err != nil { + return AddrInfo{}, err + } + return ai, nil +} diff --git a/pkg/xtcpnl/xtcpnl_ifinfomsg.go b/pkg/xtcpnl/xtcpnl_ifinfomsg.go new file mode 100644 index 0000000..db7ca6e --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_ifinfomsg.go @@ -0,0 +1,98 @@ +package xtcpnl + +import ( + "bytes" + "encoding/binary" + "errors" + + "golang.org/x/sys/unix" +) + +// IfInfomsg mirrors the kernel's `struct ifinfomsg` — the family header of an +// RTM_*LINK message. +// +// struct ifinfomsg { +// unsigned char ifi_family; +// unsigned char __ifi_pad; +// unsigned short ifi_type; +// int ifi_index; +// unsigned ifi_flags; +// unsigned ifi_change; +// }; +// +// Reference: https://github.com/torvalds/linux/blob/master/include/uapi/linux/rtnetlink.h +type IfInfomsg struct { + Family uint8 // 1 + Pad uint8 // 1 + Type uint16 // 2 + Index int32 // 4 + Flags uint32 // 4 + Change uint32 // 4 = 16 ( 16 / 4 = 4 ) +} + +const ( + IfInfomsgSizeCst = 16 + IfInfomsgReadCst = IfInfomsgSizeCst +) + +var ( + ErrIfInfomsgSmall = errors.New("data too small for IfInfomsg") +) + +// DeserializeIfInfomsg does a binary read of an IfInfomsg with a basic length +// check. +func DeserializeIfInfomsg(data []byte, m *IfInfomsg) (n int, err error) { + if len(data) < IfInfomsgSizeCst { + return 0, ErrIfInfomsgSmall + } + + m.Family = data[0] + m.Pad = data[1] + m.Type = binary.LittleEndian.Uint16(data[2:4]) + m.Index = int32(binary.LittleEndian.Uint32(data[4:8])) + m.Flags = binary.LittleEndian.Uint32(data[8:12]) + m.Change = binary.LittleEndian.Uint32(data[12:16]) + + return IfInfomsgReadCst, nil +} + +func DeserializeIfInfomsgReflection(data []byte, m *IfInfomsg) (n int, err error) { + reader := bytes.NewReader(data) + + err = binary.Read(reader, binary.LittleEndian, m) + if err != nil { + return 0, err + } + + return IfInfomsgReadCst, err +} + +// LinkInfo is the subset of an RTM_NEWLINK message xtcp2 keeps: the interface +// index, flags, and name (IFLA_IFNAME), used to label addresses/routes per +// link. +type LinkInfo struct { + Index int32 + Flags uint32 + Name string +} + +// ParseNewLink decodes an RTM_NEWLINK message body (the bytes after the +// nlmsghdr): the ifinfomsg header followed by IFLA_* attributes. Only +// IFLA_IFNAME is extracted. +func ParseNewLink(body []byte) (LinkInfo, error) { + var m IfInfomsg + if _, err := DeserializeIfInfomsg(body, &m); err != nil { + return LinkInfo{}, err + } + + li := LinkInfo{Index: m.Index, Flags: m.Flags} + err := walkRTAttrs(body[IfInfomsgSizeCst:], func(atype uint16, val []byte) { + if atype == uint16(unix.IFLA_IFNAME) { + li.Name = string(bytes.TrimRight(val, "\x00")) + } + }) + if err != nil { + return LinkInfo{}, err + } + return li, nil +} diff --git a/pkg/xtcpnl/xtcpnl_rtmsg.go b/pkg/xtcpnl/xtcpnl_rtmsg.go new file mode 100644 index 0000000..a020e70 --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_rtmsg.go @@ -0,0 +1,142 @@ +package xtcpnl + +import ( + "bytes" + "encoding/binary" + "errors" + + "golang.org/x/sys/unix" +) + +// RtMsg mirrors the kernel's `struct rtmsg` — the family header of an RTM_*ROUTE +// message. +// +// struct rtmsg { +// unsigned char rtm_family; +// unsigned char rtm_dst_len; +// unsigned char rtm_src_len; +// unsigned char rtm_tos; +// unsigned char rtm_table; /* Routing table id */ +// unsigned char rtm_protocol; /* Routing protocol; see below */ +// unsigned char rtm_scope; /* See below */ +// unsigned char rtm_type; /* See below */ +// unsigned rtm_flags; +// }; +// +// Reference: https://github.com/torvalds/linux/blob/master/include/uapi/linux/rtnetlink.h +type RtMsg struct { + Family uint8 // 1 + DstLen uint8 // 1 + SrcLen uint8 // 1 + Tos uint8 // 1 + Table uint8 // 1 + Protocol uint8 // 1 + Scope uint8 // 1 + Type uint8 // 1 + Flags uint32 // 4 = 12 ( 12 / 4 = 3 ) +} + +const ( + RtMsgSizeCst = 12 + RtMsgReadCst = RtMsgSizeCst +) + +var ( + ErrRtMsgSmall = errors.New("data too small for RtMsg") +) + +// DeserializeRtMsg does a binary read of an RtMsg with a basic length check. +func DeserializeRtMsg(data []byte, m *RtMsg) (n int, err error) { + if len(data) < RtMsgSizeCst { + return 0, ErrRtMsgSmall + } + + m.Family = data[0] + m.DstLen = data[1] + m.SrcLen = data[2] + m.Tos = data[3] + m.Table = data[4] + m.Protocol = data[5] + m.Scope = data[6] + m.Type = data[7] + m.Flags = binary.LittleEndian.Uint32(data[8:12]) + + return RtMsgReadCst, nil +} + +func DeserializeRtMsgReflection(data []byte, m *RtMsg) (n int, err error) { + reader := bytes.NewReader(data) + + err = binary.Read(reader, binary.LittleEndian, m) + if err != nil { + return 0, err + } + + return RtMsgReadCst, err +} + +// RouteInfo is the subset of an RTM_NEWROUTE message xtcp2 keeps. DstLen and the +// header table/scope/type come from the rtmsg header; Dst/Gateway/PrefSrc hold +// raw network-order address bytes. Table is upgraded from RTA_TABLE when present +// (full table ids exceed the 8-bit header field). The connected-subnet test is +// Type==RTN_UNICAST && Gateway==nil && has a Dst prefix (NOT scope-gated: IPv4 +// connected subnets are scope-link but IPv6 connected subnets are +// scope-universe); a locally-attached address is Type==RTN_LOCAL (typically in +// RT_TABLE_LOCAL, scope host). +type RouteInfo struct { + Family uint8 + DstLen uint8 + Table uint32 // header rtm_table, upgraded by RTA_TABLE + Scope uint8 + Type uint8 + Protocol uint8 + Dst []byte // RTA_DST + Gateway []byte // RTA_GATEWAY + PrefSrc []byte // RTA_PREFSRC + Oif uint32 // RTA_OIF + Priority uint32 // RTA_PRIORITY +} + +// ParseNewRoute decodes an RTM_NEWROUTE message body (the bytes after the +// nlmsghdr): the rtmsg header followed by RTA_* attributes. +func ParseNewRoute(body []byte) (RouteInfo, error) { + var m RtMsg + if _, err := DeserializeRtMsg(body, &m); err != nil { + return RouteInfo{}, err + } + + ri := RouteInfo{ + Family: m.Family, + DstLen: m.DstLen, + Table: uint32(m.Table), + Scope: m.Scope, + Type: m.Type, + Protocol: m.Protocol, + } + err := walkRTAttrs(body[RtMsgSizeCst:], func(atype uint16, val []byte) { + switch atype { + case uint16(unix.RTA_DST): + ri.Dst = copyBytes(val) + case uint16(unix.RTA_GATEWAY): + ri.Gateway = copyBytes(val) + case uint16(unix.RTA_PREFSRC): + ri.PrefSrc = copyBytes(val) + case uint16(unix.RTA_OIF): + if len(val) >= 4 { + ri.Oif = binary.LittleEndian.Uint32(val[0:4]) + } + case uint16(unix.RTA_PRIORITY): + if len(val) >= 4 { + ri.Priority = binary.LittleEndian.Uint32(val[0:4]) + } + case uint16(unix.RTA_TABLE): + if len(val) >= 4 { + ri.Table = binary.LittleEndian.Uint32(val[0:4]) + } + } + }) + if err != nil { + return RouteInfo{}, err + } + return ri, nil +} diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink.go b/pkg/xtcpnl/xtcpnl_rtnetlink.go new file mode 100644 index 0000000..61b7d83 --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_rtnetlink.go @@ -0,0 +1,189 @@ +package xtcpnl + +// This file adds the rtnetlink (NETLINK_ROUTE) DUMP machinery xtcp2 needs to +// discover a network namespace's local links, addresses and routes so socket +// endpoints can be classified as self / connected-subnet / remote before the +// IP->ASN lookup. +// +// It mirrors the existing inet_diag request/parse style in this package: manual +// little-endian (de)serialisation with explicit length checks (the host targets +// are amd64/arm64, both little-endian). The kernel UAPI enum values (RTM_*, +// IFA_*, RTA_*, RTN_*, RT_SCOPE_*, RT_TABLE_*, NLM_*, NLMSG_*) are taken from +// golang.org/x/sys/unix, which exports all of them. +// +// A DUMP request is one nlmsghdr (NLM_F_REQUEST|NLM_F_DUMP) followed by the +// family header (ifinfomsg / ifaddrmsg / rtmsg). The kernel replies with a +// multipart stream of RTM_NEW* messages terminated by NLMSG_DONE; DumpRtnetlink +// drives that stream. + +import ( + "encoding/binary" + "errors" + "fmt" + "syscall" + + "golang.org/x/sys/unix" +) + +const ( + // rtnetlinkRecvBufCst bounds a single Recvfrom. A busy host's route dump is + // large (many /32 local-table entries); 64 KiB holds many messages per + // recv, and DumpRtnetlink loops recvs until NLMSG_DONE regardless. + rtnetlinkRecvBufCst = 64 * 1024 +) + +var ( + // ErrShortRecv indicates a recv returned fewer bytes than a bare nlmsghdr. + ErrShortRecv = errors.New("xtcpnl: rtnetlink recv shorter than nlmsghdr") + // ErrBadMsgLen indicates a message length that is impossible or overruns + // the received buffer. + ErrBadMsgLen = errors.New("xtcpnl: rtnetlink message length out of range") + // ErrNetlinkError indicates a malformed NLMSG_ERROR (too short for errno). + ErrNetlinkError = errors.New("xtcpnl: rtnetlink error message truncated") +) + +// buildDumpRequest lays out a DUMP request: a 16-byte nlmsghdr +// (NLM_F_REQUEST|NLM_F_DUMP) followed by the caller's family header, which the +// caller has already sized (ifinfomsg 16, ifaddrmsg 8, rtmsg 12) and populated +// with at least its family byte. All three sizes are already 4-byte aligned. +func buildDumpRequest(msgType uint16, seq uint32, familyHdr []byte) []byte { + total := NlMsgHdrSizeCst + len(familyHdr) + b := make([]byte, total) + + binary.LittleEndian.PutUint32(b[0:4], uint32(total)) // nlmsg_len + binary.LittleEndian.PutUint16(b[4:6], msgType) // nlmsg_type + binary.LittleEndian.PutUint16(b[6:8], uint16(unix.NLM_F_REQUEST|unix.NLM_F_DUMP)) // nlmsg_flags + binary.LittleEndian.PutUint32(b[8:12], seq) // nlmsg_seq + // b[12:16] nlmsg_pid = 0 (kernel fills the peer pid) + + copy(b[NlMsgHdrSizeCst:], familyHdr) + return b +} + +// BuildDumpLinkRequest builds an RTM_GETLINK dump request (ifinfomsg, +// AF_UNSPEC) to enumerate all links. +func BuildDumpLinkRequest(seq uint32) []byte { + hdr := make([]byte, IfInfomsgSizeCst) + hdr[0] = unix.AF_UNSPEC + return buildDumpRequest(uint16(unix.RTM_GETLINK), seq, hdr) +} + +// BuildDumpAddrRequest builds an RTM_GETADDR dump request (ifaddrmsg) for the +// given address family (unix.AF_INET, unix.AF_INET6, or unix.AF_UNSPEC for +// both). +func BuildDumpAddrRequest(family uint8, seq uint32) []byte { + hdr := make([]byte, IfAddrmsgSizeCst) + hdr[0] = family + return buildDumpRequest(uint16(unix.RTM_GETADDR), seq, hdr) +} + +// BuildDumpRouteRequest builds an RTM_GETROUTE dump request (rtmsg) for the +// given address family. The kernel dumps the main table by default; callers +// wanting the local table read RTA_TABLE on each reply (RouteInfo.Table). +func BuildDumpRouteRequest(family uint8, seq uint32) []byte { + hdr := make([]byte, RtMsgSizeCst) + hdr[0] = family + return buildDumpRequest(uint16(unix.RTM_GETROUTE), seq, hdr) +} + +// DumpRtnetlink sends request on fd and drives the multipart reply, invoking +// onMsg for every RTM_NEW* message body (the bytes after the 16-byte nlmsghdr). +// It returns nil at NLMSG_DONE (or a zero-errno ACK), a wrapped syscall.Errno +// for a non-zero NLMSG_ERROR, and skips NLMSG_NOOP. The socket should have a +// receive timeout set so a missing DONE degrades to an error instead of +// blocking. onMsg must copy any bytes it needs to retain — the receive buffer +// is reused across recvs. +func DumpRtnetlink(fd int, request []byte, sa *unix.SockaddrNetlink, onMsg func(msgType uint16, body []byte) error) error { + if err := unix.Sendto(fd, request, 0, sa); err != nil { + return fmt.Errorf("xtcpnl: rtnetlink send: %w", err) + } + + buf := make([]byte, rtnetlinkRecvBufCst) + for { + n, _, err := unix.Recvfrom(fd, buf, 0) + if err != nil { + return fmt.Errorf("xtcpnl: rtnetlink recv: %w", err) + } + if n < NlMsgHdrSizeCst { + return ErrShortRecv + } + + data := buf[:n] + for len(data) >= NlMsgHdrSizeCst { + var h NlMsgHdr + if _, err := DeserializeNlMsgHdr(data, &h); err != nil { + return err + } + msgLen := int(h.Len) + if msgLen < NlMsgHdrSizeCst || msgLen > len(data) { + return ErrBadMsgLen + } + + switch h.Type { + case uint16(unix.NLMSG_DONE): + return nil + case uint16(unix.NLMSG_ERROR): + return netlinkErr(data[NlMsgHdrSizeCst:msgLen]) + case uint16(unix.NLMSG_NOOP): + // nothing to do + default: + if err := onMsg(h.Type, data[NlMsgHdrSizeCst:msgLen]); err != nil { + return err + } + } + + adv := msgLen + FourByteAlignPadding(msgLen) + if adv <= 0 || adv > len(data) { + break + } + data = data[adv:] + } + } +} + +// netlinkErr decodes an NLMSG_ERROR body. The kernel puts a negative errno in +// the first int32; a zero errno is an ACK (not an error). +func netlinkErr(body []byte) error { + if len(body) < 4 { + return ErrNetlinkError + } + errno := int32(binary.LittleEndian.Uint32(body[0:4])) + if errno == 0 { + return nil + } + return fmt.Errorf("xtcpnl: rtnetlink error: %w", syscall.Errno(-errno)) +} + +// walkRTAttrs iterates the RTAttr TLVs in data, calling fn for each with its +// type and value slice (a view into data — copy what you retain). It validates +// each attribute length and advances by the 4-byte-aligned length, tolerating a +// short trailing remainder like the kernel's NLA_ALIGN walk. +func walkRTAttrs(data []byte, fn func(atype uint16, val []byte)) error { + for len(data) >= RTAttrSizeCst { + var rta RTAttr + if _, err := DeserializeRTAttr(data, &rta); err != nil { + return err + } + alen := int(rta.Len) + if alen < RTAttrSizeCst || alen > len(data) { + return ErrRTAttrSmall + } + fn(rta.Type, data[RTAttrSizeCst:alen]) + + adv := alen + FourByteAlignPadding(alen) + if adv <= 0 || adv > len(data) { + break + } + data = data[adv:] + } + return nil +} + +// copyBytes returns a fresh copy of b, or nil for an empty slice, so parsed +// results never alias the reused receive buffer. +func copyBytes(b []byte) []byte { + if len(b) == 0 { + return nil + } + return append([]byte(nil), b...) +} diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink_realfixtures_test.go b/pkg/xtcpnl/xtcpnl_rtnetlink_realfixtures_test.go new file mode 100644 index 0000000..88fc879 --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_rtnetlink_realfixtures_test.go @@ -0,0 +1,412 @@ +package xtcpnl + +import ( + "os" + "reflect" + "testing" + + "golang.org/x/sys/unix" +) + +// This file holds the REAL-fixture-driven deserialize tests for the rtnetlink +// dump parsers. Unlike xtcpnl_rtnetlink_test.go (which synthesises exact +// positive/negative/boundary/corner wire bytes in-code), these tests read the +// committed multi-message dump fixtures captured on a live 7.1.8 kernel with +// nlmon (see xtcpnl_extract_7_1_8_fixtures_test.go and +// nix/capture-netlink-fixtures.nix) and assert that ParseNewLink / ParseNewAddr +// / ParseNewRoute decode the real kernel bytes into the structs transcribed from +// the ip_link_n / ip_addr_n / ip_route_table_all_n source-of-truth sidecars. +// +// Every expected value below cites the sidecar line it came from, exactly how +// the TCPInfo cases cite ss_tcp_info_n. The fixtures are walked the same way the +// runtime DumpRtnetlink transport does: from PcapNetlinkOffsetCst through +// walkDumpPayload, stopping at NLMSG_DONE. +// +// Interface index -> name (ip_link_n): 1 lo, 2 enp1s0, 3 enp35s0f0np0, +// 4 enp35s0f1np1, 7 virbr0, 8 docker0, 9 br-3a5828b2963a, 58 ve-nfb-vpn, +// 59 ve-nordlayepDd-, 60 veth179a698, 161 nlmon0. + +// readDumpFixture reads a committed *_dump.pcap, walks its multipart payload the +// same way DumpRtnetlink does (slice from PcapNetlinkOffsetCst, then +// walkDumpPayload), and returns a copy of every RTM_NEW* body of wantType along +// with whether the dump was terminated by NLMSG_DONE. +func readDumpFixture(t *testing.T, path string, wantType uint16) (bodies [][]byte, sawDone bool) { + t.Helper() + bs, err := os.ReadFile(path) + if err != nil { + t.Fatalf("ReadFile(%s): %v", path, err) + } + if len(bs) < PcapNetlinkOffsetCst { + t.Fatalf("%s: fixture too small (%d bytes)", path, len(bs)) + } + walkDumpPayload(bs[PcapNetlinkOffsetCst:], func(mt uint16, body []byte) bool { + if mt == uint16(unix.NLMSG_DONE) { + sawDone = true + return false + } + if mt == wantType { + bodies = append(bodies, append([]byte(nil), body...)) + } + return true + }) + return bodies, sawDone +} + +// countDeepEqual returns how many parsed entries deep-equal want. +func countDeepEqual[T any](items []T, want T) int { + n := 0 + for _, it := range items { + if reflect.DeepEqual(it, want) { + n++ + } + } + return n +} + +// TestParseNewLinkRealFixture parses the real RTM_NEWLINK dump and asserts the +// interface index/flags/name for representative links against ip_link_n. +// +// go test ./pkg/xtcpnl/ -run TestParseNewLinkRealFixture +func TestParseNewLinkRealFixture(t *testing.T) { + bodies, sawDone := readDumpFixture(t, tdRouteGetLinkDump_7_1_8, uint16(unix.RTM_NEWLINK)) + if !sawDone { + t.Fatalf("%s: dump not terminated by NLMSG_DONE", tdRouteGetLinkDump_7_1_8) + } + // Fixture integrity: the capture holds exactly the 11 links in ip_link_n. + if len(bodies) != 11 { + t.Fatalf("RTM_NEWLINK count = %d, want 11", len(bodies)) + } + + links := make([]LinkInfo, 0, len(bodies)) + for i, b := range bodies { + li, err := ParseNewLink(b) + if err != nil { + t.Fatalf("ParseNewLink(msg %d): %v", i, err) + } + links = append(links, li) + } + + tests := []struct { + description string + want LinkInfo + }{ + { + // ip_link_n:1 "1: lo: " + description: "positive: loopback lo, index 1, IFF_UP|IFF_LOOPBACK set", + want: LinkInfo{Index: 1, Flags: 0x10049, Name: "lo"}, + }, + { + // ip_link_n:3 "2: enp1s0: " + description: "positive: primary NIC enp1s0, index 2", + want: LinkInfo{Index: 2, Flags: 0x11043, Name: "enp1s0"}, + }, + { + // ip_link_n:6 "3: enp35s0f0np0: " + description: "positive: NIC enp35s0f0np0, index 3", + want: LinkInfo{Index: 3, Flags: 0x11043, Name: "enp35s0f0np0"}, + }, + { + // ip_link_n:24 "59: ve-nordlayepDd-@if2" — kernel truncates the name + // at IFNAMSIZ, so the dump carries the truncated form, not the altname. + description: "corner: long veth name truncated by the kernel, index 59", + want: LinkInfo{Index: 59, Flags: 0x11043, Name: "ve-nordlayepDd-"}, + }, + { + // ip_link_n:32 "161: nlmon0: " — the monitor iface + // the capture itself created; NOARP set, no BROADCAST/MULTICAST. + description: "corner: the capture's own nlmon0 monitor iface, index 161", + want: LinkInfo{Index: 161, Flags: 0x100c1, Name: "nlmon0"}, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if n := countDeepEqual(links, tc.want); n != 1 { + t.Errorf("found %d links equal to %+v, want exactly 1\nall links: %+v", n, tc.want, links) + } + }) + } +} + +// TestParseNewAddrRealFixtures parses the real RTM_NEWADDR v4 and v6 dumps and +// asserts representative addresses against ip_addr_n. It exercises the IPv4 +// path (kernel sends both IFA_ADDRESS and IFA_LOCAL, plus IFA_LABEL) and the +// IPv6 path (IFA_ADDRESS only, no label), across host/global/link scopes. +// +// go test ./pkg/xtcpnl/ -run TestParseNewAddrRealFixtures +func TestParseNewAddrRealFixtures(t *testing.T) { + type fixture struct { + path string + wantCount int + } + v4 := fixture{tdRouteGetAddrV4Dump_7_1_8, 9} + v6 := fixture{tdRouteGetAddrV6Dump_7_1_8, 15} + + parsed := map[string][]AddrInfo{} + for _, f := range []fixture{v4, v6} { + bodies, sawDone := readDumpFixture(t, f.path, uint16(unix.RTM_NEWADDR)) + if !sawDone { + t.Fatalf("%s: dump not terminated by NLMSG_DONE", f.path) + } + if len(bodies) != f.wantCount { + t.Fatalf("%s: RTM_NEWADDR count = %d, want %d", f.path, len(bodies), f.wantCount) + } + addrs := make([]AddrInfo, 0, len(bodies)) + for i, b := range bodies { + ai, err := ParseNewAddr(b) + if err != nil { + t.Fatalf("%s: ParseNewAddr(msg %d): %v", f.path, i, err) + } + addrs = append(addrs, ai) + } + parsed[f.path] = addrs + } + + tests := []struct { + description string + fixture string + want AddrInfo + }{ + { + // ip_addr_n:3 "inet 127.0.0.1/8 scope host lo" + description: "positive v4: loopback 127.0.0.1/8 scope host on lo (idx 1)", + fixture: v4.path, + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 8, Scope: unix.RT_SCOPE_HOST, Index: 1, + Address: v4b(127, 0, 0, 1), Local: v4b(127, 0, 0, 1), Label: "lo", + }, + }, + { + // ip_addr_n:10 "inet 172.16.50.219/24 ... scope global ... enp1s0" + description: "positive v4: global 172.16.50.219/24 on enp1s0 (idx 2)", + fixture: v4.path, + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 24, Scope: unix.RT_SCOPE_UNIVERSE, Index: 2, + Address: v4b(172, 16, 50, 219), Local: v4b(172, 16, 50, 219), Label: "enp1s0", + }, + }, + { + // ip_addr_n:23 "inet 10.10.4.2/29 scope global enp35s0f0np0" + description: "positive v4: connected-subnet host 10.10.4.2/29 on enp35s0f0np0 (idx 3)", + fixture: v4.path, + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 29, Scope: unix.RT_SCOPE_UNIVERSE, Index: 3, + Address: v4b(10, 10, 4, 2), Local: v4b(10, 10, 4, 2), Label: "enp35s0f0np0", + }, + }, + { + // ip_addr_n:62 "inet 10.98.0.1/32 scope global ve-nfb-vpn" + description: "boundary v4: /32 host address 10.98.0.1 on veth (idx 58)", + fixture: v4.path, + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 32, Scope: unix.RT_SCOPE_UNIVERSE, Index: 58, + Address: v4b(10, 98, 0, 1), Local: v4b(10, 98, 0, 1), Label: "ve-nfb-vpn", + }, + }, + { + // ip_addr_n:5 "inet6 ::1/128 scope host" — v6 carries IFA_ADDRESS + // only (Local nil) and no IFA_LABEL. + description: "boundary v6: loopback ::1/128 scope host on lo (idx 1), no local/label", + fixture: v6.path, + want: AddrInfo{ + Family: unix.AF_INET6, Prefixlen: 128, Scope: unix.RT_SCOPE_HOST, Index: 1, + Address: mustV6(t, "::1"), + }, + }, + { + // ip_addr_n:25 "inet6 fd10:10:4::2/64 scope global nodad" + description: "positive v6: ULA fd10:10:4::2/64 scope global on enp35s0f0np0 (idx 3)", + fixture: v6.path, + want: AddrInfo{ + Family: unix.AF_INET6, Prefixlen: 64, Scope: unix.RT_SCOPE_UNIVERSE, Index: 3, + Address: mustV6(t, "fd10:10:4::2"), + }, + }, + { + // ip_addr_n:18 "inet6 fe80::b5c8:b23e:9a98:a37c/64 scope link" + description: "positive v6: link-local fe80::…a37c/64 scope link on enp1s0 (idx 2)", + fixture: v6.path, + want: AddrInfo{ + Family: unix.AF_INET6, Prefixlen: 64, Scope: unix.RT_SCOPE_LINK, Index: 2, + Address: mustV6(t, "fe80::b5c8:b23e:9a98:a37c"), + }, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if n := countDeepEqual(parsed[tc.fixture], tc.want); n != 1 { + t.Errorf("found %d addrs equal to %+v, want exactly 1", n, tc.want) + } + }) + } +} + +// TestParseNewRouteRealFixture parses the real RTM_NEWROUTE dump (main + local +// tables, v4 + v6) and asserts representative routes against +// ip_route_table_all_n: a connected subnet, a default via gateway, and a local +// host route, for both families. +// +// go test ./pkg/xtcpnl/ -run TestParseNewRouteRealFixture +func TestParseNewRouteRealFixture(t *testing.T) { + bodies, sawDone := readDumpFixture(t, tdRouteGetRouteDump_7_1_8, uint16(unix.RTM_NEWROUTE)) + if !sawDone { + t.Fatalf("%s: dump not terminated by NLMSG_DONE", tdRouteGetRouteDump_7_1_8) + } + // Fixture integrity: 26 IPv4 + 48 IPv6 routes across main and local tables. + if len(bodies) != 74 { + t.Fatalf("RTM_NEWROUTE count = %d, want 74", len(bodies)) + } + routes := make([]RouteInfo, 0, len(bodies)) + for i, b := range bodies { + ri, err := ParseNewRoute(b) + if err != nil { + t.Fatalf("ParseNewRoute(msg %d): %v", i, err) + } + routes = append(routes, ri) + } + + tests := []struct { + description string + want RouteInfo + }{ + { + // ip_route_table_all_n:1 + // "unicast default via 172.16.50.1 dev enp1s0 table main proto dhcp + // scope global src 172.16.50.219 metric 100" + description: "positive v4: default route via gateway (no RTA_DST, DstLen 0)", + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 0, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_DHCP, + Gateway: v4b(172, 16, 50, 1), PrefSrc: v4b(172, 16, 50, 219), Oif: 2, Priority: 100, + }, + }, + { + // ip_route_table_all_n:2 + // "unicast 10.10.4.0/29 dev enp35s0f0np0 table main proto kernel + // scope link src 10.10.4.2" + description: "positive v4: connected subnet 10.10.4.0/29 (scope LINK, unicast, no gateway)", + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 29, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_KERNEL, + Dst: v4b(10, 10, 4, 0), PrefSrc: v4b(10, 10, 4, 2), Oif: 3, + }, + }, + { + // ip_route_table_all_n:16 + // "local 127.0.0.0/8 dev lo table local proto kernel scope host + // src 127.0.0.1" + description: "positive v4: local route 127.0.0.0/8 (type LOCAL, table LOCAL, scope HOST)", + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 8, Table: unix.RT_TABLE_LOCAL, + Scope: unix.RT_SCOPE_HOST, Type: unix.RTN_LOCAL, Protocol: unix.RTPROT_KERNEL, + Dst: v4b(127, 0, 0, 0), PrefSrc: v4b(127, 0, 0, 1), Oif: 1, + }, + }, + { + // ip_route_table_all_n:29 + // "unicast fd10:10:4::/64 dev enp35s0f0np0 table main proto kernel + // scope global metric 256 pref medium" + // + // The bug-catching case: an IPv6 connected subnet is scope GLOBAL + // (RT_SCOPE_UNIVERSE=0), NOT scope-link. localnet's connected-subnet + // rule must therefore key on unicast+no-gateway+has-Dst, not scope. + description: "positive v6: connected subnet fd10:10:4::/64 (scope UNIVERSE, unicast, no gateway)", + want: RouteInfo{ + Family: unix.AF_INET6, DstLen: 64, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_KERNEL, + Dst: mustV6(t, "fd10:10:4::"), Oif: 3, Priority: 256, + }, + }, + { + // ip_route_table_all_n:39 + // "unicast default via fe80::e638:83ff:fe36:8f0d dev enp1s0 table main + // proto ra scope global metric 100 pref high" + description: "positive v6: default route via link-local gateway (DstLen 0)", + want: RouteInfo{ + Family: unix.AF_INET6, DstLen: 0, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_RA, + Gateway: mustV6(t, "fe80::e638:83ff:fe36:8f0d"), Oif: 2, Priority: 100, + }, + }, + { + // ip_route_table_all_n:40 + // "local ::1 dev lo table local proto kernel scope global metric 0" + // Note: unlike the IPv4 loopback local route (scope HOST), the v6 ::1 + // local route is scope GLOBAL. + description: "boundary v6: local host route ::1/128 (type LOCAL, table LOCAL, scope GLOBAL)", + want: RouteInfo{ + Family: unix.AF_INET6, DstLen: 128, Table: unix.RT_TABLE_LOCAL, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_LOCAL, Protocol: unix.RTPROT_KERNEL, + Dst: mustV6(t, "::1"), Oif: 1, + }, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if n := countDeepEqual(routes, tc.want); n != 1 { + t.Errorf("found %d routes equal to %+v, want exactly 1", n, tc.want) + } + }) + } +} + +// TestRealFixtureConnectedSubnetScope documents and guards the finding that +// distinguishes a connected subnet by family: IPv4 connected subnets carry +// scope RT_SCOPE_LINK while IPv6 connected subnets carry scope RT_SCOPE_UNIVERSE. +// A scope-gated connected-subnet rule would silently misclassify every IPv6 +// on-link subnet as REMOTE — this test fails if that asymmetry ever regresses in +// the fixtures, keeping localnet.BuildSnapshot's family-agnostic rule honest. +// +// go test ./pkg/xtcpnl/ -run TestRealFixtureConnectedSubnetScope +func TestRealFixtureConnectedSubnetScope(t *testing.T) { + bodies, _ := readDumpFixture(t, tdRouteGetRouteDump_7_1_8, uint16(unix.RTM_NEWROUTE)) + + // connected returns the parsed connected-subnet route (unicast, no gateway, + // has a Dst prefix, in the main table) whose Dst equals wantDst. + connected := func(wantDst []byte) (RouteInfo, bool) { + for _, b := range bodies { + ri, err := ParseNewRoute(b) + if err != nil { + continue + } + if ri.Type != unix.RTN_UNICAST || len(ri.Gateway) != 0 || len(ri.Dst) == 0 { + continue + } + if ri.Table == unix.RT_TABLE_MAIN && reflect.DeepEqual(ri.Dst, wantDst) { + return ri, true + } + } + return RouteInfo{}, false + } + + tests := []struct { + description string + dst []byte + wantScope uint8 + }{ + { + description: "IPv4 connected subnet 10.10.4.0/29 is scope RT_SCOPE_LINK", + dst: v4b(10, 10, 4, 0), + wantScope: unix.RT_SCOPE_LINK, + }, + { + description: "IPv6 connected subnet fd10:10:4::/64 is scope RT_SCOPE_UNIVERSE (NOT link)", + dst: mustV6(t, "fd10:10:4::"), + wantScope: unix.RT_SCOPE_UNIVERSE, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + ri, ok := connected(tc.dst) + if !ok { + t.Fatalf("connected route for %v not found in fixture", tc.dst) + } + if ri.Scope != tc.wantScope { + t.Errorf("scope = %d, want %d", ri.Scope, tc.wantScope) + } + }) + } +} diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink_test.go b/pkg/xtcpnl/xtcpnl_rtnetlink_test.go new file mode 100644 index 0000000..282e49f --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_rtnetlink_test.go @@ -0,0 +1,880 @@ +package xtcpnl + +import ( + "encoding/binary" + "errors" + "net/netip" + "reflect" + "syscall" + "testing" + + "golang.org/x/sys/unix" +) + +// ---- byte builders ----------------------------------------------------------- +// +// These synthesize rtnetlink wire bytes so the parser tests can express exact +// positive/negative/boundary/corner inputs without a live kernel. They mirror +// the layout DumpRtnetlink and the Parse* functions consume: a family header +// followed by 4-byte-aligned RTAttr TLVs, and (for the transport test) a +// 16-byte nlmsghdr in front of each message. + +// rtattr encodes one RTAttr TLV (4-byte header + value) padded to 4 bytes. +func rtattr(atype uint16, val []byte) []byte { + alen := RTAttrSizeCst + len(val) + pad := FourByteAlignPadding(alen) + b := make([]byte, alen+pad) + binary.LittleEndian.PutUint16(b[0:2], uint16(alen)) + binary.LittleEndian.PutUint16(b[2:4], atype) + copy(b[RTAttrSizeCst:], val) + return b +} + +// ifaddrmsgHdr encodes an 8-byte ifaddrmsg family header. +func ifaddrmsgHdr(family, prefixlen, flags, scope uint8, index uint32) []byte { + b := make([]byte, IfAddrmsgSizeCst) + b[0] = family + b[1] = prefixlen + b[2] = flags + b[3] = scope + binary.LittleEndian.PutUint32(b[4:8], index) + return b +} + +// rtmsgHdr encodes a 12-byte rtmsg family header. +func rtmsgHdr(family, dstLen, tos, table, protocol, scope, rtype uint8, flags uint32) []byte { + b := make([]byte, RtMsgSizeCst) + b[0] = family + b[1] = dstLen + // b[2] src_len = 0 + b[3] = tos + b[4] = table + b[5] = protocol + b[6] = scope + b[7] = rtype + binary.LittleEndian.PutUint32(b[8:12], flags) + return b +} + +// ifinfomsgHdr encodes a 16-byte ifinfomsg family header. +func ifinfomsgHdr(family uint8, itype uint16, index int32, flags uint32) []byte { + b := make([]byte, IfInfomsgSizeCst) + b[0] = family + binary.LittleEndian.PutUint16(b[2:4], itype) + binary.LittleEndian.PutUint32(b[4:8], uint32(index)) + binary.LittleEndian.PutUint32(b[8:12], flags) + return b +} + +func v4b(a, b, c, d byte) []byte { return []byte{a, b, c, d} } + +// ---- deserializer tests ------------------------------------------------------ + +// TestDeserializeIfAddrmsg checks the 8-byte ifaddrmsg header decoder against +// both the manual and reflection implementations, with positive/boundary/corner +// rows. +// +// go test ./pkg/xtcpnl/ -run TestDeserializeIfAddrmsg +func TestDeserializeIfAddrmsg(t *testing.T) { + tests := []struct { + description string + data []byte + want IfAddrmsg + wantErr error + }{ + { + description: "positive: IPv4 /24 scope-universe on ifindex 2", + data: ifaddrmsgHdr(unix.AF_INET, 24, 0, unix.RT_SCOPE_UNIVERSE, 2), + want: IfAddrmsg{Family: unix.AF_INET, Prefixlen: 24, Scope: unix.RT_SCOPE_UNIVERSE, Index: 2}, + }, + { + description: "boundary: /0 prefix, ifindex 0", + data: ifaddrmsgHdr(unix.AF_INET6, 0, 0, 0, 0), + want: IfAddrmsg{Family: unix.AF_INET6}, + }, + { + description: "boundary: trailing attribute bytes are ignored by the header decoder", + data: append(ifaddrmsgHdr(unix.AF_INET, 32, 0, unix.RT_SCOPE_HOST, 1), 0xde, 0xad), + want: IfAddrmsg{Family: unix.AF_INET, Prefixlen: 32, Scope: unix.RT_SCOPE_HOST, Index: 1}, + }, + { + description: "corner: one byte short -> ErrIfAddrmsgSmall", + data: make([]byte, IfAddrmsgSizeCst-1), + wantErr: ErrIfAddrmsgSmall, + }, + { + description: "corner: empty input -> ErrIfAddrmsgSmall", + data: nil, + wantErr: ErrIfAddrmsgSmall, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var manual, refl IfAddrmsg + _, errM := DeserializeIfAddrmsg(tc.data, &manual) + if !errors.Is(errM, tc.wantErr) { + t.Fatalf("manual err = %v, want %v", errM, tc.wantErr) + } + if tc.wantErr != nil { + return + } + if manual != tc.want { + t.Errorf("manual = %+v, want %+v", manual, tc.want) + } + // The reflection decoder needs exactly the struct's worth of bytes. + if _, errR := DeserializeIfAddrmsgReflection(tc.data[:IfAddrmsgSizeCst], &refl); errR != nil { + t.Fatalf("reflection err = %v", errR) + } + if refl != tc.want { + t.Errorf("reflection = %+v, want %+v", refl, tc.want) + } + }) + } +} + +// TestDeserializeRtMsg checks the 12-byte rtmsg header decoder. +// +// go test ./pkg/xtcpnl/ -run TestDeserializeRtMsg +func TestDeserializeRtMsg(t *testing.T) { + tests := []struct { + description string + data []byte + want RtMsg + wantErr error + }{ + { + description: "positive: connected /24 unicast scope-link in main table", + data: rtmsgHdr(unix.AF_INET, 24, 0, unix.RT_TABLE_MAIN, unix.RTPROT_KERNEL, unix.RT_SCOPE_LINK, unix.RTN_UNICAST, 0), + want: RtMsg{ + Family: unix.AF_INET, DstLen: 24, Table: unix.RT_TABLE_MAIN, + Protocol: unix.RTPROT_KERNEL, Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, + }, + }, + { + description: "positive: local host route /32 scope-host in local table", + data: rtmsgHdr(unix.AF_INET, 32, 0, unix.RT_TABLE_LOCAL, unix.RTPROT_KERNEL, unix.RT_SCOPE_HOST, unix.RTN_LOCAL, 0), + want: RtMsg{ + Family: unix.AF_INET, DstLen: 32, Table: unix.RT_TABLE_LOCAL, + Protocol: unix.RTPROT_KERNEL, Scope: unix.RT_SCOPE_HOST, Type: unix.RTN_LOCAL, + }, + }, + { + description: "boundary: all-zero header decodes to the zero value", + data: make([]byte, RtMsgSizeCst), + want: RtMsg{}, + }, + { + description: "corner: one byte short -> ErrRtMsgSmall", + data: make([]byte, RtMsgSizeCst-1), + wantErr: ErrRtMsgSmall, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var manual, refl RtMsg + _, errM := DeserializeRtMsg(tc.data, &manual) + if !errors.Is(errM, tc.wantErr) { + t.Fatalf("manual err = %v, want %v", errM, tc.wantErr) + } + if tc.wantErr != nil { + return + } + if manual != tc.want { + t.Errorf("manual = %+v, want %+v", manual, tc.want) + } + if _, errR := DeserializeRtMsgReflection(tc.data[:RtMsgSizeCst], &refl); errR != nil { + t.Fatalf("reflection err = %v", errR) + } + if refl != tc.want { + t.Errorf("reflection = %+v, want %+v", refl, tc.want) + } + }) + } +} + +// TestDeserializeIfInfomsg checks the 16-byte ifinfomsg header decoder. +// +// go test ./pkg/xtcpnl/ -run TestDeserializeIfInfomsg +func TestDeserializeIfInfomsg(t *testing.T) { + tests := []struct { + description string + data []byte + want IfInfomsg + wantErr error + }{ + { + description: "positive: ethernet link index 2, IFF_UP", + data: ifinfomsgHdr(unix.AF_UNSPEC, 1 /*ARPHRD_ETHER*/, 2, unix.IFF_UP), + want: IfInfomsg{Family: unix.AF_UNSPEC, Type: 1, Index: 2, Flags: unix.IFF_UP}, + }, + { + description: "boundary: loopback index 1", + data: ifinfomsgHdr(unix.AF_UNSPEC, 772 /*ARPHRD_LOOPBACK*/, 1, unix.IFF_UP|unix.IFF_LOOPBACK), + want: IfInfomsg{Family: unix.AF_UNSPEC, Type: 772, Index: 1, Flags: unix.IFF_UP | unix.IFF_LOOPBACK}, + }, + { + description: "corner: one byte short -> ErrIfInfomsgSmall", + data: make([]byte, IfInfomsgSizeCst-1), + wantErr: ErrIfInfomsgSmall, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var manual, refl IfInfomsg + _, errM := DeserializeIfInfomsg(tc.data, &manual) + if !errors.Is(errM, tc.wantErr) { + t.Fatalf("manual err = %v, want %v", errM, tc.wantErr) + } + if tc.wantErr != nil { + return + } + if manual != tc.want { + t.Errorf("manual = %+v, want %+v", manual, tc.want) + } + if _, errR := DeserializeIfInfomsgReflection(tc.data[:IfInfomsgSizeCst], &refl); errR != nil { + t.Fatalf("reflection err = %v", errR) + } + if refl != tc.want { + t.Errorf("reflection = %+v, want %+v", refl, tc.want) + } + }) + } +} + +// ---- parser tests ------------------------------------------------------------ + +// TestParseNewAddr decodes RTM_NEWADDR bodies (ifaddrmsg + IFA_* attributes). +// +// go test ./pkg/xtcpnl/ -run TestParseNewAddr +func TestParseNewAddr(t *testing.T) { + tests := []struct { + description string + body []byte + want AddrInfo + wantErr bool + }{ + { + description: "positive: IPv4 with IFA_ADDRESS, IFA_LOCAL and IFA_LABEL", + body: concat( + ifaddrmsgHdr(unix.AF_INET, 24, 0, unix.RT_SCOPE_UNIVERSE, 2), + rtattr(unix.IFA_ADDRESS, v4b(10, 0, 0, 5)), + rtattr(unix.IFA_LOCAL, v4b(10, 0, 0, 5)), + rtattr(unix.IFA_LABEL, append([]byte("eth0"), 0)), + ), + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 24, Scope: unix.RT_SCOPE_UNIVERSE, Index: 2, + Address: v4b(10, 0, 0, 5), Local: v4b(10, 0, 0, 5), Label: "eth0", + }, + }, + { + description: "positive: IPv6 /64 with only IFA_ADDRESS", + body: concat( + ifaddrmsgHdr(unix.AF_INET6, 64, 0, unix.RT_SCOPE_UNIVERSE, 2), + rtattr(unix.IFA_ADDRESS, mustV6(t, "2001:db8::5")), + ), + want: AddrInfo{ + Family: unix.AF_INET6, Prefixlen: 64, Scope: unix.RT_SCOPE_UNIVERSE, Index: 2, + Address: mustV6(t, "2001:db8::5"), + }, + }, + { + description: "positive: point-to-point IPv4 where IFA_LOCAL differs from IFA_ADDRESS (peer)", + body: concat( + ifaddrmsgHdr(unix.AF_INET, 32, 0, unix.RT_SCOPE_UNIVERSE, 3), + rtattr(unix.IFA_LOCAL, v4b(10, 8, 0, 1)), + rtattr(unix.IFA_ADDRESS, v4b(10, 8, 0, 2)), + ), + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 32, Scope: unix.RT_SCOPE_UNIVERSE, Index: 3, + Local: v4b(10, 8, 0, 1), Address: v4b(10, 8, 0, 2), + }, + }, + { + description: "boundary: header only, no attributes", + body: ifaddrmsgHdr(unix.AF_INET, 32, 0, unix.RT_SCOPE_HOST, 1), + want: AddrInfo{Family: unix.AF_INET, Prefixlen: 32, Scope: unix.RT_SCOPE_HOST, Index: 1}, + }, + { + description: "corner: unknown attribute types are ignored", + body: concat( + ifaddrmsgHdr(unix.AF_INET, 24, 0, unix.RT_SCOPE_UNIVERSE, 2), + rtattr(unix.IFA_FLAGS, []byte{0, 0, 0, 0x80}), + rtattr(unix.IFA_ADDRESS, v4b(192, 168, 1, 2)), + ), + want: AddrInfo{ + Family: unix.AF_INET, Prefixlen: 24, Scope: unix.RT_SCOPE_UNIVERSE, Index: 2, + Address: v4b(192, 168, 1, 2), + }, + }, + { + description: "corner: truncated ifaddrmsg header -> error", + body: make([]byte, IfAddrmsgSizeCst-1), + wantErr: true, + }, + { + description: "corner: attribute length below the 4-byte header -> error", + body: concat( + ifaddrmsgHdr(unix.AF_INET, 24, 0, unix.RT_SCOPE_UNIVERSE, 2), + []byte{0x02, 0x00, byte(unix.IFA_ADDRESS), 0x00}, // alen=2 (< RTAttrSizeCst) + ), + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got, err := ParseNewAddr(tc.body) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got %+v", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !reflect.DeepEqual(got, tc.want) { + t.Errorf("ParseNewAddr = %+v, want %+v", got, tc.want) + } + }) + } +} + +// TestParseNewRoute decodes RTM_NEWROUTE bodies (rtmsg + RTA_* attributes). +// +// go test ./pkg/xtcpnl/ -run TestParseNewRoute +func TestParseNewRoute(t *testing.T) { + tests := []struct { + description string + body []byte + want RouteInfo + wantErr bool + }{ + { + description: "positive: connected /24 (scope-link, no gateway) with PREFSRC and OIF", + body: concat( + rtmsgHdr(unix.AF_INET, 24, 0, unix.RT_TABLE_MAIN, unix.RTPROT_KERNEL, unix.RT_SCOPE_LINK, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 0, 0, 0)), + rtattr(unix.RTA_PREFSRC, v4b(10, 0, 0, 5)), + rtattr(unix.RTA_OIF, le32(2)), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 24, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_KERNEL, + Dst: v4b(10, 0, 0, 0), PrefSrc: v4b(10, 0, 0, 5), Oif: 2, + }, + }, + { + description: "positive: default route via gateway with RTA_PRIORITY", + body: concat( + rtmsgHdr(unix.AF_INET, 0, 0, unix.RT_TABLE_MAIN, unix.RTPROT_BOOT, unix.RT_SCOPE_UNIVERSE, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_GATEWAY, v4b(10, 0, 0, 1)), + rtattr(unix.RTA_OIF, le32(2)), + rtattr(unix.RTA_PRIORITY, le32(100)), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 0, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_BOOT, + Gateway: v4b(10, 0, 0, 1), Oif: 2, Priority: 100, + }, + }, + { + description: "positive: RTA_TABLE upgrades the 8-bit header table id", + body: concat( + rtmsgHdr(unix.AF_INET, 32, 0, 0 /*RT_TABLE_UNSPEC in header*/, unix.RTPROT_KERNEL, unix.RT_SCOPE_HOST, unix.RTN_LOCAL, 0), + rtattr(unix.RTA_DST, v4b(172, 16, 0, 1)), + rtattr(unix.RTA_TABLE, le32(unix.RT_TABLE_LOCAL)), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 32, Table: unix.RT_TABLE_LOCAL, + Scope: unix.RT_SCOPE_HOST, Type: unix.RTN_LOCAL, Protocol: unix.RTPROT_KERNEL, + Dst: v4b(172, 16, 0, 1), + }, + }, + { + description: "positive: IPv6 connected /64", + body: concat( + rtmsgHdr(unix.AF_INET6, 64, 0, unix.RT_TABLE_MAIN, unix.RTPROT_KERNEL, unix.RT_SCOPE_LINK, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, mustV6(t, "2001:db8::")), + rtattr(unix.RTA_OIF, le32(2)), + ), + want: RouteInfo{ + Family: unix.AF_INET6, DstLen: 64, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_KERNEL, + Dst: mustV6(t, "2001:db8::"), Oif: 2, + }, + }, + { + description: "boundary: rtmsg header with no attributes", + body: rtmsgHdr(unix.AF_INET, 0, 0, unix.RT_TABLE_MAIN, 0, 0, unix.RTN_UNICAST, 0), + want: RouteInfo{Family: unix.AF_INET, Table: unix.RT_TABLE_MAIN, Type: unix.RTN_UNICAST}, + }, + { + description: "corner: short RTA_OIF (2 bytes) is ignored, leaving Oif zero", + body: concat( + rtmsgHdr(unix.AF_INET, 24, 0, unix.RT_TABLE_MAIN, 0, unix.RT_SCOPE_LINK, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 0, 0, 0)), + rtattr(unix.RTA_OIF, []byte{0x02, 0x00}), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 24, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, Dst: v4b(10, 0, 0, 0), + }, + }, + { + description: "corner: truncated rtmsg header -> error", + body: make([]byte, RtMsgSizeCst-1), + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got, err := ParseNewRoute(tc.body) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got %+v", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !reflect.DeepEqual(got, tc.want) { + t.Errorf("ParseNewRoute = %+v, want %+v", got, tc.want) + } + }) + } +} + +// TestParseNewLink decodes RTM_NEWLINK bodies (ifinfomsg + IFLA_IFNAME). +// +// go test ./pkg/xtcpnl/ -run TestParseNewLink +func TestParseNewLink(t *testing.T) { + tests := []struct { + description string + body []byte + want LinkInfo + wantErr bool + }{ + { + description: "positive: eth0 with IFLA_IFNAME", + body: concat( + ifinfomsgHdr(unix.AF_UNSPEC, 1, 2, unix.IFF_UP), + rtattr(unix.IFLA_IFNAME, append([]byte("eth0"), 0)), + ), + want: LinkInfo{Index: 2, Flags: unix.IFF_UP, Name: "eth0"}, + }, + { + description: "boundary: loopback with no IFLA_IFNAME", + body: ifinfomsgHdr(unix.AF_UNSPEC, 772, 1, unix.IFF_UP|unix.IFF_LOOPBACK), + want: LinkInfo{Index: 1, Flags: unix.IFF_UP | unix.IFF_LOOPBACK}, + }, + { + description: "corner: other IFLA attributes ignored, name still extracted", + body: concat( + ifinfomsgHdr(unix.AF_UNSPEC, 1, 5, unix.IFF_UP), + rtattr(unix.IFLA_MTU, le32(1500)), + rtattr(unix.IFLA_IFNAME, append([]byte("wg0"), 0)), + ), + want: LinkInfo{Index: 5, Flags: unix.IFF_UP, Name: "wg0"}, + }, + { + description: "corner: truncated ifinfomsg header -> error", + body: make([]byte, IfInfomsgSizeCst-1), + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got, err := ParseNewLink(tc.body) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got %+v", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !reflect.DeepEqual(got, tc.want) { + t.Errorf("ParseNewLink = %+v, want %+v", got, tc.want) + } + }) + } +} + +// ---- request builder tests --------------------------------------------------- + +// TestBuildDumpRequests verifies each DUMP request builder emits a well-formed +// nlmsghdr (correct length, type, REQUEST|DUMP flags, seq) followed by a family +// header of the right size carrying the requested family. +// +// go test ./pkg/xtcpnl/ -run TestBuildDumpRequests +func TestBuildDumpRequests(t *testing.T) { + const wantFlags = uint16(unix.NLM_F_REQUEST | unix.NLM_F_DUMP) + + tests := []struct { + description string + req []byte + wantType uint16 + wantSeq uint32 + hdrSize int + wantFamily uint8 + }{ + { + description: "RTM_GETLINK: ifinfomsg, AF_UNSPEC", + req: BuildDumpLinkRequest(1), + wantType: uint16(unix.RTM_GETLINK), + wantSeq: 1, + hdrSize: IfInfomsgSizeCst, + wantFamily: unix.AF_UNSPEC, + }, + { + description: "RTM_GETADDR: ifaddrmsg, AF_INET", + req: BuildDumpAddrRequest(unix.AF_INET, 2), + wantType: uint16(unix.RTM_GETADDR), + wantSeq: 2, + hdrSize: IfAddrmsgSizeCst, + wantFamily: unix.AF_INET, + }, + { + description: "RTM_GETROUTE: rtmsg, AF_INET6", + req: BuildDumpRouteRequest(unix.AF_INET6, 3), + wantType: uint16(unix.RTM_GETROUTE), + wantSeq: 3, + hdrSize: RtMsgSizeCst, + wantFamily: unix.AF_INET6, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + wantLen := NlMsgHdrSizeCst + tc.hdrSize + if len(tc.req) != wantLen { + t.Fatalf("len(req) = %d, want %d", len(tc.req), wantLen) + } + var h NlMsgHdr + if _, err := DeserializeNlMsgHdr(tc.req, &h); err != nil { + t.Fatalf("DeserializeNlMsgHdr: %v", err) + } + if int(h.Len) != wantLen { + t.Errorf("nlmsg_len = %d, want %d", h.Len, wantLen) + } + if h.Type != tc.wantType { + t.Errorf("nlmsg_type = %d, want %d", h.Type, tc.wantType) + } + if h.Flags != wantFlags { + t.Errorf("nlmsg_flags = %#x, want %#x", h.Flags, wantFlags) + } + if h.Seq != tc.wantSeq { + t.Errorf("nlmsg_seq = %d, want %d", h.Seq, tc.wantSeq) + } + if fam := tc.req[NlMsgHdrSizeCst]; fam != tc.wantFamily { + t.Errorf("family byte = %d, want %d", fam, tc.wantFamily) + } + }) + } +} + +// ---- walkRTAttrs / netlinkErr tests ------------------------------------------ + +// TestWalkRTAttrs covers the TLV walker's positive iteration and its +// truncation/short-length rejection. +// +// go test ./pkg/xtcpnl/ -run TestWalkRTAttrs +func TestWalkRTAttrs(t *testing.T) { + tests := []struct { + description string + data []byte + wantTypes []uint16 + wantErr bool + }{ + { + description: "positive: two attributes with padding walked in order", + data: concat(rtattr(1, []byte{0xaa}), rtattr(2, []byte{0xbb, 0xcc, 0xdd, 0xee})), + wantTypes: []uint16{1, 2}, + }, + { + description: "boundary: empty input yields no callbacks", + data: nil, + wantTypes: nil, + }, + { + description: "boundary: a lone 4-byte (empty-value) attribute", + data: rtattr(7, nil), + wantTypes: []uint16{7}, + }, + { + description: "corner: sub-header trailing bytes are tolerated (kernel NLA_ALIGN walk)", + data: append(rtattr(1, []byte{0x01}), 0x00, 0x00), + wantTypes: []uint16{1}, + }, + { + description: "corner: attribute length below header -> error", + data: []byte{0x02, 0x00, 0x01, 0x00}, + wantErr: true, + }, + { + description: "corner: attribute length beyond buffer -> error", + data: []byte{0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}, + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var got []uint16 + err := walkRTAttrs(tc.data, func(atype uint16, _ []byte) { + got = append(got, atype) + }) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got types %v", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !reflect.DeepEqual(got, tc.wantTypes) { + t.Errorf("types = %v, want %v", got, tc.wantTypes) + } + }) + } +} + +// TestNetlinkErr covers the NLMSG_ERROR body decoder: a zero errno is an ACK +// (nil), a negative errno maps to a syscall.Errno, and a too-short body errors. +// +// go test ./pkg/xtcpnl/ -run TestNetlinkErr +func TestNetlinkErr(t *testing.T) { + tests := []struct { + description string + body []byte + wantErr error + wantErrno syscall.Errno + }{ + { + description: "positive: zero errno is an ACK -> nil", + body: le32(0), + wantErr: nil, + }, + { + description: "positive: -EPERM maps to EPERM", + body: negErrno(syscall.EPERM), + wantErrno: syscall.EPERM, + }, + { + description: "positive: -ENODEV maps to ENODEV", + body: negErrno(syscall.ENODEV), + wantErrno: syscall.ENODEV, + }, + { + description: "corner: body shorter than 4 bytes -> ErrNetlinkError", + body: []byte{0x00, 0x00}, + wantErr: ErrNetlinkError, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + err := netlinkErr(tc.body) + switch { + case tc.wantErrno != 0: + if !errors.Is(err, tc.wantErrno) { + t.Errorf("err = %v, want errno %v", err, tc.wantErrno) + } + case tc.wantErr != nil: + if !errors.Is(err, tc.wantErr) { + t.Errorf("err = %v, want %v", err, tc.wantErr) + } + default: + if err != nil { + t.Errorf("err = %v, want nil", err) + } + } + }) + } +} + +// ---- DumpRtnetlink integration test ------------------------------------------ + +// TestDumpRtnetlinkLive is an integration test against the running kernel's +// NETLINK_ROUTE: it dumps the current namespace's links and asserts a loopback +// interface is present. It is skipped when a route socket cannot be opened +// (restricted sandbox / CI without netlink), so it never blocks the build. +// +// go test ./pkg/xtcpnl/ -run TestDumpRtnetlinkLive +func TestDumpRtnetlinkLive(t *testing.T) { + fd, err := unix.Socket(unix.AF_NETLINK, unix.SOCK_RAW|unix.SOCK_CLOEXEC, unix.NETLINK_ROUTE) + if err != nil { + t.Skipf("netlink route socket unavailable: %v", err) + } + defer func() { + if cerr := unix.Close(fd); cerr != nil { + t.Logf("close fd: %v", cerr) + } + }() + + sa := &unix.SockaddrNetlink{Family: unix.AF_NETLINK} + if berr := unix.Bind(fd, sa); berr != nil { + t.Skipf("bind netlink socket: %v", berr) + } + tv := unix.Timeval{Sec: 2} + if serr := unix.SetsockoptTimeval(fd, unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv); serr != nil { + t.Skipf("set recv timeout: %v", serr) + } + + var names []string + err = DumpRtnetlink(fd, BuildDumpLinkRequest(1), sa, func(mt uint16, body []byte) error { + if mt != uint16(unix.RTM_NEWLINK) { + return nil + } + li, perr := ParseNewLink(body) + if perr != nil { + return perr + } + names = append(names, li.Name) + return nil + }) + if err != nil { + t.Fatalf("DumpRtnetlink(GETLINK): %v", err) + } + + if len(names) == 0 { + t.Fatal("no links returned from RTM_GETLINK dump") + } + hasLo := false + for _, n := range names { + if n == "lo" { + hasLo = true + } + } + if !hasLo { + t.Errorf("loopback 'lo' not found among links: %v", names) + } + + // The address dump should decode cleanly and include the loopback address. + var sawLoopback bool + err = DumpRtnetlink(fd, BuildDumpAddrRequest(unix.AF_UNSPEC, 2), sa, func(mt uint16, body []byte) error { + if mt != uint16(unix.RTM_NEWADDR) { + return nil + } + ai, perr := ParseNewAddr(body) + if perr != nil { + return perr + } + raw := ai.Local + if len(raw) == 0 { + raw = ai.Address + } + if len(raw) == 4 && raw[0] == 127 { + sawLoopback = true + } + if len(raw) == 16 && raw[15] == 1 && allZero(raw[:15]) { + sawLoopback = true + } + return nil + }) + if err != nil { + t.Fatalf("DumpRtnetlink(GETADDR): %v", err) + } + if !sawLoopback { + t.Log("note: no loopback address seen in RTM_GETADDR dump (unusual but not fatal)") + } + + // The route dump should decode cleanly. + var routeCount int + err = DumpRtnetlink(fd, BuildDumpRouteRequest(unix.AF_UNSPEC, 3), sa, func(mt uint16, body []byte) error { + if mt != uint16(unix.RTM_NEWROUTE) { + return nil + } + if _, perr := ParseNewRoute(body); perr != nil { + return perr + } + routeCount++ + return nil + }) + if err != nil { + t.Fatalf("DumpRtnetlink(GETROUTE): %v", err) + } + t.Logf("live dump: %d links, %d routes", len(names), routeCount) +} + +// ---- fuzz -------------------------------------------------------------------- + +// FuzzParseNewAddr ensures ParseNewAddr never panics on arbitrary bytes. +func FuzzParseNewAddr(f *testing.F) { + f.Add(ifaddrmsgHdr(unix.AF_INET, 24, 0, unix.RT_SCOPE_UNIVERSE, 2)) + f.Add(concat(ifaddrmsgHdr(unix.AF_INET, 24, 0, 0, 2), rtattr(unix.IFA_ADDRESS, v4b(10, 0, 0, 5)))) + f.Add([]byte{}) + f.Fuzz(func(_ *testing.T, body []byte) { + _, _ = ParseNewAddr(body) + }) +} + +// FuzzParseNewRoute ensures ParseNewRoute never panics on arbitrary bytes. +func FuzzParseNewRoute(f *testing.F) { + f.Add(rtmsgHdr(unix.AF_INET, 24, 0, unix.RT_TABLE_MAIN, 0, unix.RT_SCOPE_LINK, unix.RTN_UNICAST, 0)) + f.Add(concat(rtmsgHdr(unix.AF_INET, 0, 0, unix.RT_TABLE_MAIN, 0, 0, unix.RTN_UNICAST, 0), rtattr(unix.RTA_GATEWAY, v4b(10, 0, 0, 1)))) + f.Add([]byte{}) + f.Fuzz(func(_ *testing.T, body []byte) { + _, _ = ParseNewRoute(body) + }) +} + +// FuzzParseNewLink ensures ParseNewLink never panics on arbitrary bytes. +func FuzzParseNewLink(f *testing.F) { + f.Add(concat(ifinfomsgHdr(unix.AF_UNSPEC, 1, 2, unix.IFF_UP), rtattr(unix.IFLA_IFNAME, append([]byte("eth0"), 0)))) + f.Add([]byte{}) + f.Fuzz(func(_ *testing.T, body []byte) { + _, _ = ParseNewLink(body) + }) +} + +// ---- small helpers ----------------------------------------------------------- + +func concat(parts ...[]byte) []byte { + var out []byte + for _, p := range parts { + out = append(out, p...) + } + return out +} + +func le32(v uint32) []byte { + b := make([]byte, 4) + binary.LittleEndian.PutUint32(b, v) + return b +} + +// negErrno encodes the kernel's NLMSG_ERROR payload for errno e: a negative +// int32 in little-endian. Computed at runtime to avoid constant overflow. +func negErrno(e syscall.Errno) []byte { + n := -int32(e) + return le32(uint32(n)) +} + +func mustV6(t *testing.T, s string) []byte { + t.Helper() + a, err := netip.ParseAddr(s) + if err != nil || !a.Is6() { + t.Fatalf("bad IPv6 %q: %v", s, err) + } + b := a.As16() + return b[:] +} + +func allZero(b []byte) bool { + for _, x := range b { + if x != 0 { + return false + } + } + return true +} diff --git a/proto/xtcp_config/v1/xtcp_config.proto b/proto/xtcp_config/v1/xtcp_config.proto index 385e703..5c6cca4 100644 --- a/proto/xtcp_config/v1/xtcp_config.proto +++ b/proto/xtcp_config/v1/xtcp_config.proto @@ -875,6 +875,20 @@ message XtcpConfig { // How often to reload asn_db_path in the background so a refreshed artifact // is picked up without a restart. 0 = load once at startup, never reload. google.protobuf.Duration asn_refresh_interval = 241; + + // Classify the destination IP's locality (field 1019) — self / + // connected-subnet / remote — from each monitored network namespace's local + // addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs + // BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: + // a per-namespace discovery failure just leaves that namespace's sockets + // unclassified. Default false. + bool enrich_locality_enable = 242; + + // How often to re-discover local addresses/routes per namespace so runtime + // changes (interfaces up/down, routes added) are picked up. Newly-appeared + // namespaces are always snapshotted on the next reconcile regardless. 0 = + // discover once per namespace, never refresh. + google.protobuf.Duration locality_refresh_interval = 243; }; message EnabledDeserializers { diff --git a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto index c4e8794..1b23825 100644 --- a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto +++ b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto @@ -181,6 +181,21 @@ message XtcpFlatRecord { // destination IP is not in the feed set. string inet_diag_msg_socket_dest_network_owner = 1018; + // Destination endpoint locality, classified from the socket's own network + // namespace's local addresses + routing table (discovered via rtnetlink, + // see pkg/localnet). Populated by the opt-in locality enricher BEFORE the + // ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, + // so dest_asn (1011) / dest_network_owner (1018) stay empty for them. + // UNSPECIFIED when locality enrichment is disabled or the namespace has no + // snapshot yet. + enum Locality { + LOCALITY_UNSPECIFIED = 0; + LOCALITY_SELF = 1; // one of this host/namespace's own addresses (or loopback) + LOCALITY_LOCAL_SUBNET = 2; // on a directly-connected subnet (one L2 hop, no gateway) + LOCALITY_REMOTE = 3; // reached via a gateway (falls through to ASN lookup) + }; + Locality inet_diag_msg_socket_dest_locality = 1019; + // might want to put more here // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 From 62a4673552f54e6925ba85cadffd9cd9d7b6c179 Mon Sep 17 00:00:00 2001 From: "randomizedcoder dave.seddon.ca@gmail.com" Date: Tue, 22 Sep 2026 15:17:27 -0700 Subject: [PATCH 4/4] feat(enrichment): harden ASN/locality enrichment, protobuf structure v2, lookup-table metrics Review of the stacked ipfeed-collector/ASN and locality enrichment work found contained but real holes; this commit closes them and adds the operational metrics for the IP->ASN lookup table. Protobuf structure v2 (XtcpFlatRecordSchemaVersion 1 -> 2) - xtcp_flat_record.proto: documented allocation policy (metadata 1-299, enrichment 300-399, spare 400-999, payload 1000+ per kernel subsystem, every tag <= 2047); enrichment block regrouped by subject (socket-side 300s, dest-side 310s/320s, source-side reserved 350-389). - Payload field names now mirror the kernel struct member they copy and every payload field carries a trailing comment naming its kernel source (include/uapi/linux/{inet_diag,tcp,sock_diag}.h, net/ipv4/inet_diag.c). Renames: tcp_info_{snd,rcv}_wscale, fastopen_client_fail, rttvar, advmss, notsent_bytes; sk_mem_info_{rcvbuf,sndbuf}; vegas_info_{rttcnt,minrtt}; inet_diag_{cong,cong_enum,tos,tclass,shutdown,class_id,sockopt,cgroup_id}. Old numbers/names are reserved; post-6.10 tcp_info members pre-assigned 1266-1276 by comment. tools/proto-field-audit gains a kernel-annotation guard so a payload field cannot land without its source. - XtcpConfig renumbered into blocks (gRPC-internal only, nothing persists it). - Propagated to gen/*, ParquetRow/rowFromProto, recordfmt, the ClickHouse Kafka table + per-version MVs (_v2 table, explicit column aliases for _v0/_v1), k8s configMaps, hand-written SQL, and docs (protobuf-formats, parquet-format, record-versioning, socket-analysis). build/containers/clickhouse/sql/migrations/v2.sql for existing deployments. Locality classification and lifecycle (pkg/localnet, pkg/xtcpnl, pkg/xtcp) - RTN_LOCAL uses the route's real prefix; multipath/RTA_VIA/RTA_NH_ID routes classify as gateway-reached (Remote, oif 0); Self wins over Subnet regardless of dump order; only RT_TABLE_MAIN/LOCAL are read; unspecified destinations -> LOCALITY_UNSPECIFIED. - Failed namespaces are negative-cached with backoff; loopback-only snapshots are re-dumped; new-namespace dumps per reconcile are capped; NLM_F_DUMP_INTR is retried; default locality_refresh_interval 60s. - DumpRtnetlink loop factored into walkNlMsgs with table + fuzz tests over real nlmon captures; refreshLocality tests via an injected dumper. ASN enricher hardening (pkg/ipasn, pkg/xtcp, internal/ipfeed, cmd/*) - ipasn: only io.EOF ends a read, zero usable prefixes is ErrNoPrefixes, a bad reload never degrades the table in service, ReloadIfChanged skips an unchanged artifact by stat. - initAsnEnricher installs the index even when the first load fails so a late-arriving artifact is picked up on the refresh tick. - output.WriteParquet is atomic (.tmp + fsync + rename); fetch bodies are capped at 256 MiB; -enrichAsn/-asnDbPath/-asnRefreshInterval flags + env. - Tests for the six previously untested feed parsers, summary, envInt, s3.parseEndpoint; tabularised the remaining ad-hoc tests. Lookup-table metrics (operational visibility) - Daemon: function="loadAsn" gauges prefixes / artifactBytes / loadedAt and summaries build / error duration, published by one loadAsn helper used by both the start-up load and the refresh tick; ipasn.Index.Stats() backs it. - Collector: OTel instruments bridged to Prometheus via go.opentelemetry.io/otel/exporters/prometheus on a private registry and served as /metrics on the daemon health server. New instruments: ipfeed.source.records, ipfeed.artifact.records, ipfeed.artifact.size, ipfeed.write.duration, ipfeed.upload.duration, ipfeed.cycle.duration. - goVendorHash updated for the new dependency. E2E and tooling - self-test check 5f distinguishes bound vs egress records; check 5g asserts the ASN, owner, locality AND the loadAsn/prefixes gauge (fixture-derived); client units Restart=always; TestPrintFlags nil-deref fixed. Verification: go vet/gofmt clean; go test ./... green (-race on localnet, xtcpnl, ipasn, xtcp, telemetry, health); golangci-lint only the pre-existing govet unusedwrite; proto-field-audit clean; nix build .#xtcp2-all; nix run .#test-microvm-lifecycle-x86_64-interface-naming OVERALL PASS (XTCP2_SELF_TEST_ASN_PASS dest=8.8.8.8:53 asn=15169 owner=google prefixes=3). Co-Authored-By: Claude Opus 4.8 --- .../format_schemas/xtcp_flat_record.proto | 536 ++- .../xtcp_flat_record_repeated.proto | 477 -- .../initdb.d/sql/xtcp_xtcp_flat_records.sql | 306 +- .../sql/xtcp_xtcp_flat_records_kafka.sql | 140 +- .../sql/xtcp_xtcp_flat_records_mv.sql | 384 +- .../clickhouse/select_statements.sql | 2 +- .../clickhouse/sql/migrations/v2.sql | 966 ++++ build/containers/clickhouse/sql_queries.sql | 2 +- .../bootstrap-mounted-configMap.cue | 7 + .../bootstrap-mounted-configMap.yaml | 7 + .../clickhouse/example.proto.configMap.yaml | 7 + .../flatxtcppb.proto.configMap.yaml | 7 + build/k8s/clickhouse/readme.md | 20 + cmd/ipfeed-collector/DESIGN.md | 443 +- cmd/ipfeed-collector/README.md | 153 +- cmd/ipfeed-collector/main.go | 63 +- cmd/ipfeed-collector/main_test.go | 81 +- cmd/xtcp2/xtcp2.go | 92 +- cmd/xtcp2/xtcp2_test.go | 87 + cmd/xtcp2client/xtcp2client_test.go | 2 +- docs/design-metadata-enrichment.md | 5 + docs/integration-testing.md | 1 + docs/ipfeed-asn-enrichment.md | 102 +- docs/locality-enrichment.md | 119 +- docs/output-and-destinations.md | 2 +- docs/parquet-format.md | 28 +- docs/protobuf-formats.md | 47 +- docs/protobuflist-migration.md | 2 +- docs/record-versioning.md | 132 +- docs/socket-analysis.md | 10 +- gen/cpp/xtcp_config/v1/xtcp_config.grpc.pb.h | 4 +- gen/cpp/xtcp_config/v1/xtcp_config.pb.cc | 2742 +++++------ gen/cpp/xtcp_config/v1/xtcp_config.pb.h | 4058 ++++++++--------- .../v1/xtcp_flat_record.grpc.pb.h | 52 +- .../v1/xtcp_flat_record.pb.cc | 2480 +++++----- .../xtcp_flat_record/v1/xtcp_flat_record.pb.h | 2072 +++++---- gen/dart/xtcp_config/v1/xtcp_config.pb.dart | 1631 +++---- .../xtcp_config/v1/xtcp_config.pbjson.dart | 459 +- .../v1/xtcp_flat_record.pb.dart | 1074 +++-- .../v1/xtcp_flat_record.pbenum.dart | 10 +- .../v1/xtcp_flat_record.pbjson.dart | 451 +- gen/go/xtcp_config/xtcp_config.pb.go | 819 ++-- gen/go/xtcp_config/xtcp_config_grpc.pb.go | 4 +- gen/go/xtcp_config/xtcp_config_vtproto.pb.go | 1530 +++---- .../vtproto_conformance_test.go | 2 +- .../xtcp_flat_record/xtcp_flat_record.pb.go | 652 +-- .../xtcp_flat_record_grpc.pb.go | 52 +- .../xtcp_flat_record_vtproto.pb.go | 643 +-- .../xtcp_config/v1/xtcp_config.swagger.json | 212 +- gen/python/xtcp_config/v1/xtcp_config_pb2.py | 132 +- gen/python/xtcp_config/v1/xtcp_config_pb2.pyi | 124 +- .../v1/xtcp_flat_record_pb2.py | 32 +- .../v1/xtcp_flat_record_pb2.pyi | 98 +- go.mod | 8 +- go.sum | 18 +- internal/ipfeed/asnmap/asnmap_test.go | 96 +- internal/ipfeed/config/source.go | 16 +- internal/ipfeed/config/source_test.go | 198 +- internal/ipfeed/fetch/fetch.go | 22 +- internal/ipfeed/fetch/fetch_test.go | 73 + internal/ipfeed/health/health.go | 18 +- internal/ipfeed/health/health_test.go | 62 + internal/ipfeed/output/parquet.go | 34 +- internal/ipfeed/output/parquet_test.go | 87 + internal/ipfeed/parse/parse_more_test.go | 590 +++ internal/ipfeed/s3/uploader.go | 33 +- internal/ipfeed/s3/uploader_test.go | 42 + internal/ipfeed/summary/summary_test.go | 260 ++ internal/ipfeed/telemetry/otel.go | 118 +- internal/ipfeed/telemetry/otel_test.go | 169 + nix/capture-netlink-fixtures.nix | 10 +- nix/containers/default.nix | 17 +- nix/default.nix | 2 + nix/devshell.nix | 4 + nix/microvms/default.nix | 42 + nix/microvms/mkVm.nix | 349 ++ nix/microvms/self-test.nix | 180 + nix/versions.nix | 2 +- pkg/ipasn/ipasn.go | 141 +- pkg/ipasn/ipasn_test.go | 464 +- pkg/localnet/localnet.go | 311 +- pkg/localnet/localnet_race_test.go | 11 +- pkg/localnet/localnet_realfixtures_test.go | 64 +- pkg/localnet/localnet_test.go | 634 ++- pkg/recordfmt/bench_test.go | 6 +- pkg/recordfmt/columns.go | 8 +- pkg/recordfmt/marshal.go | 2 +- pkg/recordfmt/protobuflist_vt_test.go | 2 +- pkg/recordfmt/recordfmt_test.go | 40 +- pkg/xtcp/deserialize.go | 6 +- pkg/xtcp/deserialize_test.go | 9 +- pkg/xtcp/destinations_s3parquet.go | 120 +- pkg/xtcp/destinations_s3parquet_schema.go | 161 +- .../destinations_s3parquet_schema_test.go | 6 +- pkg/xtcp/dispatch_test.go | 16 +- pkg/xtcp/enrich.go | 149 +- pkg/xtcp/enrich_asn_test.go | 304 ++ pkg/xtcp/enrich_locality.go | 283 +- pkg/xtcp/enrich_locality_test.go | 685 +++ pkg/xtcp/prometheus.go | 11 + pkg/xtcp/schema_version.go | 15 +- pkg/xtcp/xtcp.go | 13 + pkg/xtcpnl/xtcp_writer_test.go | 10 +- pkg/xtcpnl/xtcpnl_extra_test.go | 4 +- pkg/xtcpnl/xtcpnl_inet_diag_cgroupid.go | 2 +- pkg/xtcpnl/xtcpnl_inet_diag_classid.go | 2 +- pkg/xtcpnl/xtcpnl_inet_diag_conginfo.go | 12 +- pkg/xtcpnl/xtcpnl_inet_diag_shutdown.go | 2 +- pkg/xtcpnl/xtcpnl_inet_diag_skmeminfo.go | 4 +- pkg/xtcpnl/xtcpnl_inet_diag_sockopt.go | 4 +- pkg/xtcpnl/xtcpnl_inet_diag_tcclass_info.go | 2 +- pkg/xtcpnl/xtcpnl_inet_diag_tcpinfo.go | 12 +- pkg/xtcpnl/xtcpnl_inet_diag_tosinfo.go | 2 +- pkg/xtcpnl/xtcpnl_inet_diag_vegasinfo.go | 8 +- pkg/xtcpnl/xtcpnl_rtmsg.go | 49 +- pkg/xtcpnl/xtcpnl_rtnetlink.go | 176 +- pkg/xtcpnl/xtcpnl_rtnetlink_dump_test.go | 360 ++ pkg/xtcpnl/xtcpnl_rtnetlink_test.go | 55 + proto/xtcp_config/v1/xtcp_config.proto | 664 +-- .../v1/xtcp_flat_record.proto | 536 ++- .../kernel_annotation_test.go | 334 ++ tools/proto-field-audit/main.go | 84 +- tools/tcp_client/tcp_client.go | 77 +- tools/tcp_client/tcp_client_test.go | 139 +- 124 files changed, 20585 insertions(+), 11427 deletions(-) delete mode 100644 build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto create mode 100644 build/containers/clickhouse/sql/migrations/v2.sql create mode 100644 internal/ipfeed/parse/parse_more_test.go create mode 100644 internal/ipfeed/summary/summary_test.go create mode 100644 internal/ipfeed/telemetry/otel_test.go create mode 100644 pkg/xtcp/enrich_asn_test.go create mode 100644 pkg/xtcp/enrich_locality_test.go create mode 100644 pkg/xtcpnl/xtcpnl_rtnetlink_dump_test.go create mode 100644 tools/proto-field-audit/kernel_annotation_test.go diff --git a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto index 713d608..5bbd0a6 100644 --- a/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto +++ b/build/containers/clickhouse/format_schemas/xtcp_flat_record.proto @@ -7,20 +7,52 @@ // // xTCP - eXport TCP Inet Diagnostic messages // -// These are all the structs relating to the TCP diagnotic module in the kernel +// XtcpFlatRecord is one flat row per socket: daemon metadata, daemon-computed +// enrichment, and the raw kernel inet_diag payload (struct inet_diag_msg + every +// INET_DIAG_* extension xtcp requests). Protobuf's smallest scalar is 32 bits, +// so kernel __u8/__u16 members are widened to uint32; the trailing comment on +// every payload field records the kernel member and its C type. // -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 +// Kernel source of truth (Linux 7.2-rc, include/uapi/linux/): +// inet_diag.h struct inet_diag_msg, inet_diag_sockid, inet_diag_meminfo, +// tcpvegas_info, tcp_dctcp_info, tcp_bbr_info, inet_diag_sockopt, +// enum INET_DIAG_* (extension attribute ids) +// tcp.h struct tcp_info +// sock_diag.h enum SK_MEMINFO_* +// net/ipv4/inet_diag.c inet_sk_diag_fill / inet_diag_msg_attrs_fill (what +// each nla_put_* actually carries) // -// There are links to the kernel source showing where the struct came from. +// --------------------------------------------------------------------------- +// FIELD-NUMBER ALLOCATION POLICY (v2, 2026-09) +// --------------------------------------------------------------------------- +// 1-299 metadata daemon identity, time, namespace, container, labels, +// bookkeeping, per-uplink host topology (one block each) +// 300-399 enrichment daemon-COMPUTED fields (NOT read from the kernel): +// 300-309 socket-side, 310-349 destination-side, +// 350-389 source-side (future), 390-399 spare +// 400-999 spare unallocated; open a new metadata/enrichment block here +// 1000+ payload raw kernel inet_diag data, ONE hundred-block per kernel +// struct / INET_DIAG_* extension (1000 inet_diag_msg, +// 1100 meminfo, 1200 tcp_info, 1300 cong, 1400 tos/tclass, +// 1500 skmeminfo, 1600 shutdown, 1700 vegas, 1800 dctcp, +// 1900 bbr, 2000 class_id/sockopt/cgroup_id; next free +// block = 2100) +// Wire cost: tags 1-15 = 1 byte, 16-2047 = 2 bytes, 2048+ = 3 bytes. Every field +// here is <= 2047. Fill free slots inside an existing block before opening one +// above 2047. +// Naming: payload fields are _ using the kernel's +// exact spelling (tcp_info_rttvar, not rtt_var). Attributes with no struct take +// the lowercased INET_DIAG_* name (inet_diag_tos). The six inet_diag_msg_socket_* +// sockid fields keep their descriptive names (heavily used downstream). +// Evolution: never reuse a number or a name (add both to `reserved`); any rename +// or renumber is a new record epoch -> bump XtcpFlatRecordSchemaVersion +// (pkg/xtcp/schema_version.go) and add the matching ClickHouse _vN table + MV +// (build/containers/clickhouse/initdb.d/sql/). Adding a field in a free slot is +// NOT an epoch bump. ClickHouse maps columns by field NAME; Parquet by NAME; +// the csv/tsv marshallers by DECLARATION ORDER; gRPC clients are built from +// gen/go in this repo. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder - -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto - // https://protobuf.dev/programming-guides/encoding/#structure syntax = "proto3"; @@ -28,18 +60,11 @@ syntax = "proto3"; package xtcp_flat_record.v1; // https://developers.google.com/protocol-buffers/docs/reference/go-generated -// option go_package = "github.com/randomizedcoder/xtcp2/pkg/xtcppb"; -// option go_package = "github.com/randomizedcoder/xtcp"; option go_package = "./gen/go/xtcp_flat_record"; // https://github.com/bufbuild/protovalidate -// https://buf.build/bufbuild/protovalidate/docs/main:buf.validate -// https://github.com/bufbuild/protovalidate/tree/main/examples -// https://buf.build/docs/lint/rules/?h=protovalidate#protovalidate // import "buf/validate/validate.proto"; -// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information - // Envelope is the protobufList wrapper to allow for batch inserts into Clickhouse // https://clickhouse.com/docs/en/interfaces/formats#protobuflist message Envelope { @@ -47,18 +72,39 @@ message Envelope { repeated XtcpFlatRecord row = 10; }; -// Field-number layout (reorganised 2026-08 while the record had few consumers): -// metadata ... 1-999 (identity + per-uplink network topology) -// payload ... 1000+ (kernel inet_diag subsystems, one hundred-block each) -// ClickHouse's Protobuf format maps columns by field NAME and Parquet uses its own -// schema, so the wire-tag renumber does not break ingestion or historical Parquet. +// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information message XtcpFlatRecord { + // Retired numbers/names. NEVER reuse. + // 301/302 v1 egress ifindex/ifname -> 311/312 (v2 regroup by subject) + // 1011/1012/1018/1019 v0 daemon-computed dest asn/next-hop/owner/locality + // -> 320/321/322/310 (moved out of the raw-kernel block) + // 2103 c_group -> inet_diag_cgroup_id 2003 (tidied into the 2000 block) + reserved 301, 302, 1011, 1012, 1018, 1019, 2103; + reserved "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", + "inet_diag_msg_socket_dest_network_owner", "inet_diag_msg_socket_dest_locality", + "enrich_socket_next_hop_asn", + // v1 -> v2 kernel-spelling renames (same numbers, new names) + "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_fast_open_client_failed", + "tcp_info_rtt_var", "tcp_info_adv_mss", "tcp_info_not_sent_bytes", + "sk_mem_info_rcv_buf", "sk_mem_info_snd_buf", + "vegas_info_rtt_cnt", "vegas_info_min_rtt", + // v1 -> v2 struct-less attribute renames + "congestion_algorithm_string", "congestion_algorithm_enum", + "type_of_service", "traffic_class", "shutdown_state", + "class_id", "sock_opt", "c_group"; + + // ==== metadata (1-299) ===================================================== + // Free: 3-9, 11-19, 22-29, 33-39, 44-49, 52-59, 63-99, 108-119, 125-199, + // 208-219, 225-299. Uplink slots are fixed at two (100s, 200s); a third slot + // would take 250-274, NOT 300 (that is the enrichment block). + // ---- metadata: record format provenance (1-2) ---------------------------- // Record format epoch. Stamped unconditionally into every record so consumers // can route records to per-version tables and migrate/aggregate across them. - // 0 = pre-versioning daemons (this field absent on the wire → proto3 zero - // default), which acts as the "legacy" bucket. Bump the daemon-side constant - // (XtcpFlatRecordSchemaVersion) whenever the format changes meaningfully. + // 0 = pre-versioning daemons (this field absent on the wire -> proto3 zero + // default), which acts as the "legacy" bucket. 1 = 2026-08/09 layout. + // 2 = this layout (kernel-spelled payload names, enrichment regroup). Bump the + // daemon-side constant (XtcpFlatRecordSchemaVersion) on any rename/renumber. uint32 schema_version = 1; // Daemon build provenance (git commit / build date / version, from -ldflags). @@ -67,7 +113,7 @@ message XtcpFlatRecord { string daemon_version = 2; // ---- metadata: time (10) ------------------------------------------------- - int64 timestamp_ns = 10; + int64 timestamp_ns = 10; // time.Now().UnixNano() at record build // ---- metadata: host identity (20s) --------------------------------------- string hostname = 20; @@ -128,7 +174,8 @@ message XtcpFlatRecord { // Static per boot; captured once at startup (best-effort). Hosts are // dual-homed, so there are two fixed uplink slots. All values repeat on every // record and dictionary-compress to ~nothing. NIC info: sysfs + ethtool - // ioctl. LLDP: lldpd control socket (/run/lldpd.socket). + // ioctl (100-107, free 108-119). LLDP: lldpd control socket + // (/run/lldpd.socket) (120-124, free 125-199). string uplink1_ifname = 100; string uplink1_nic_driver = 101; string uplink1_nic_model = 102; @@ -144,6 +191,7 @@ message XtcpFlatRecord { string uplink1_lldp_port_descr = 124; // ---- metadata: host network topology, uplink slot 2 (200s) --------------- + // Same layout as slot 1 (NIC 200-207, LLDP 220-224). string uplink2_ifname = 200; string uplink2_nic_driver = 201; string uplink2_nic_model = 202; @@ -158,54 +206,105 @@ message XtcpFlatRecord { string uplink2_lldp_port_id = 223; string uplink2_lldp_port_descr = 224; - // ==== payload: kernel inet_diag subsystems (1000+) ======================== - // inet_diag_msg inet_diag_msg = 1000; - - uint32 inet_diag_msg_family = 1001; // uint8 - uint32 inet_diag_msg_state = 1002; // uint8 - uint32 inet_diag_msg_timer = 1003; // uint8 - uint32 inet_diag_msg_retrans = 1004; // uint8 - - uint32 inet_diag_msg_socket_source_port = 1005; // __be16 - uint32 inet_diag_msg_socket_destination_port = 1006; // __be16 - bytes inet_diag_msg_socket_source = 1007; - bytes inet_diag_msg_socket_destination = 1008; - uint32 inet_diag_msg_socket_interface = 1009; - uint64 inet_diag_msg_socket_cookie = 1010; // [2]uint32 - uint64 inet_diag_msg_socket_dest_asn = 1011; - uint64 inet_diag_msg_socket_next_hop_asn = 1012; - - uint32 inet_diag_msg_expires = 1013; - uint32 inet_diag_msg_rqueue = 1014; - uint32 inet_diag_msg_wqueue = 1015; - uint32 inet_diag_msg_uid = 1016; - uint32 inet_diag_msg_inode = 1017; - - // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range - // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the - // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the - // destination IP is not in the feed set. - string inet_diag_msg_socket_dest_network_owner = 1018; - + // ==== enrichment: daemon-COMPUTED fields (300-399) ======================== + // These are NOT read from the kernel inet_diag message; xtcp2 computes them + // from side data (rtnetlink address/route/link discovery, the ipfeed ASN + // feeds) during enrichment. All are opt-in and best-effort: an empty/zero + // value means the relevant enricher was disabled or had no answer. + // Grouped by SUBJECT: what the socket itself is bound to (300s), then + // everything we can say about the DESTINATION endpoint (310-349), with + // 350-389 held for a future SOURCE-side mirror (locality/ASN of the local + // address for listeners / inbound flows) and 390-399 spare. + + // ---- enrichment: socket-side (300-309) ----------------------------------- + // Human name of the interface the socket is BOUND to, i.e. the resolved form + // of inet_diag_msg_socket_interface (1009, the kernel idiag_if index) via the + // namespace's RTM_GETLINK dump. Empty when idiag_if is 0 (the common case — + // most sockets are not SO_BINDTODEVICE-bound) or the index is unknown. + string enrich_socket_interface_name = 300; + // 301-309 free (301/302 retired, see reserved). + + // ---- enrichment: destination-side (310-349) ------------------------------ // Destination endpoint locality, classified from the socket's own network // namespace's local addresses + routing table (discovered via rtnetlink, - // see pkg/localnet). Populated by the opt-in locality enricher BEFORE the - // ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, - // so dest_asn (1011) / dest_network_owner (1018) stay empty for them. - // UNSPECIFIED when locality enrichment is disabled or the namespace has no - // snapshot yet. + // see pkg/localnet). Computed BEFORE the ASN lookup: SELF and LOCAL_SUBNET + // destinations never reach the ASN feed, so enrich_socket_dest_asn (320) / + // enrich_socket_dest_network_owner (322) stay empty for them. UNSPECIFIED + // when locality enrichment is disabled or the namespace has no snapshot yet. enum Locality { LOCALITY_UNSPECIFIED = 0; LOCALITY_SELF = 1; // one of this host/namespace's own addresses (or loopback) LOCALITY_LOCAL_SUBNET = 2; // on a directly-connected subnet (one L2 hop, no gateway) LOCALITY_REMOTE = 3; // reached via a gateway (falls through to ASN lookup) }; - Locality inet_diag_msg_socket_dest_locality = 1019; - - // might want to put more here - // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 - // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 - + Locality enrich_socket_dest_locality = 310; + + // The EGRESS interface for the destination, derived from the socket's own + // namespace routing table: the Oif of the route the destination longest-prefix + // matches (pkg/localnet). Unlike interface_name (1009/300) this is populated + // even for unbound sockets — it is "which NIC does traffic to this dest leave + // on". ifindex is the raw kernel index; ifname is it resolved via RTM_GETLINK. + // 0 / empty when the locality enricher is disabled or no route matched. + uint32 enrich_socket_dest_egress_ifindex = 311; + string enrich_socket_dest_egress_ifname = 312; + // 313-319 free (destination routing/locality extras). + + // Populated by the opt-in ASN enricher (pkg/ipasn) only for REMOTE + // destinations. 0 / empty when disabled or the destination IP is not in the + // feed set. network_owner is a human name (e.g. "cloudflare", "aws"). + // dest_next_hop_asn is the first-hop transit ASN toward dest; currently + // always 0 (no BGP RIB source yet) — reserved for that feed. + uint64 enrich_socket_dest_asn = 320; + uint64 enrich_socket_dest_next_hop_asn = 321; + string enrich_socket_dest_network_owner = 322; + // 323-349 free (destination identity/ownership extras). + + // ---- enrichment: source-side (350-389) — RESERVED, none defined yet ------ + // Mirror of 310-349 for the LOCAL endpoint (useful for listeners / inbound + // flows): 350 enrich_socket_src_locality, 351/352 ingress ifindex/ifname, + // 360 enrich_socket_src_asn, 362 enrich_socket_src_network_owner, ... + + // ---- enrichment: spare (390-399) ----------------------------------------- + + // ==== payload: raw kernel inet_diag (1000+) ================================ + // Prefix -> kernel struct: + // inet_diag_msg_* struct inet_diag_msg (+ .id struct inet_diag_sockid) inet_diag.h + // mem_info_* struct inet_diag_meminfo INET_DIAG_MEMINFO (1) inet_diag.h + // tcp_info_* struct tcp_info INET_DIAG_INFO (2) tcp.h + // inet_diag_cong* (string attribute) INET_DIAG_CONG (4) inet_diag.c + // inet_diag_tos (__u8 attribute) INET_DIAG_TOS (5) inet_diag.c + // inet_diag_tclass (__u8 attribute) INET_DIAG_TCLASS (6) inet_diag.c + // sk_mem_info_* __u32[SK_MEMINFO_VARS] INET_DIAG_SKMEMINFO(7) sock_diag.h + // inet_diag_shutdown (__u8 attribute) INET_DIAG_SHUTDOWN (8) inet_diag.c + // vegas_info_* struct tcpvegas_info INET_DIAG_VEGASINFO(3) inet_diag.h + // dctcp_info_* struct tcp_dctcp_info INET_DIAG_DCTCPINFO(9) inet_diag.h + // bbr_info_* struct tcp_bbr_info INET_DIAG_BBRINFO (16) inet_diag.h + // inet_diag_class_id (__u32 attribute) INET_DIAG_CLASS_ID (17) inet_diag.c + // inet_diag_sockopt struct inet_diag_sockopt INET_DIAG_SOCKOPT (22) inet_diag.h + // inet_diag_cgroup_id (__u64 attribute) INET_DIAG_CGROUP_ID(21) inet_diag.c + + // ---- payload: struct inet_diag_msg (1000s) -------------------------------- + // The fixed header of every SOCK_DIAG_BY_FAMILY reply (inet_diag.h). + // Free: 1000, 1018-1099 (1011/1012/1018/1019 retired, see reserved). + uint32 inet_diag_msg_family = 1001; // struct inet_diag_msg.idiag_family (__u8) AF_INET/AF_INET6 + uint32 inet_diag_msg_state = 1002; // struct inet_diag_msg.idiag_state (__u8) TCP_ESTABLISHED..TCP_NEW_SYN_RECV + uint32 inet_diag_msg_timer = 1003; // struct inet_diag_msg.idiag_timer (__u8) 0 none,1 retransmit,2 keepalive,3 timewait,4 zero-window probe + uint32 inet_diag_msg_retrans = 1004; // struct inet_diag_msg.idiag_retrans (__u8) + + uint32 inet_diag_msg_socket_source_port = 1005; // struct inet_diag_msg.id.idiag_sport (__be16) host order here + uint32 inet_diag_msg_socket_destination_port = 1006; // struct inet_diag_msg.id.idiag_dport (__be16) host order here + bytes inet_diag_msg_socket_source = 1007; // struct inet_diag_msg.id.idiag_src (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + bytes inet_diag_msg_socket_destination = 1008; // struct inet_diag_msg.id.idiag_dst (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + uint32 inet_diag_msg_socket_interface = 1009; // struct inet_diag_msg.id.idiag_if (__u32) bound ifindex, 0 unbound (name: 300) + uint64 inet_diag_msg_socket_cookie = 1010; // struct inet_diag_msg.id.idiag_cookie (__u32[2]) packed lo|hi<<32 + + uint32 inet_diag_msg_expires = 1013; // struct inet_diag_msg.idiag_expires (__u32) ms until idiag_timer fires + uint32 inet_diag_msg_rqueue = 1014; // struct inet_diag_msg.idiag_rqueue (__u32) + uint32 inet_diag_msg_wqueue = 1015; // struct inet_diag_msg.idiag_wqueue (__u32) + uint32 inet_diag_msg_uid = 1016; // struct inet_diag_msg.idiag_uid (__u32) + uint32 inet_diag_msg_inode = 1017; // struct inet_diag_msg.idiag_inode (__u32) + + // ---- payload: struct inet_diag_meminfo, INET_DIAG_MEMINFO 1 (1100s) ------- // DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by // default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), // so these ship as 0 on current records. The same values live in sk_mem_info: @@ -215,102 +314,119 @@ message XtcpFlatRecord { // mem_info_tmem == sk_mem_info_wmem_alloc (1503) // Field numbers retained (never reused); enable with `-deserializers all`. // (Not marked `[deprecated = true]` so the still-supported opt-in decode path - // and tests don't trip staticcheck SA1019.) - uint32 mem_info_rmem = 1101; - uint32 mem_info_wmem = 1102; - uint32 mem_info_fmem = 1103; - uint32 mem_info_tmem = 1104; - - //tcp_info tcp_info = 1200; // INET_DIAG_INFO 2 - - uint32 tcp_info_state = 1201; // uint8 - uint32 tcp_info_ca_state = 1202; // uint8 - uint32 tcp_info_retransmits = 1203; // uint8 - uint32 tcp_info_probes = 1204; // uint8 - uint32 tcp_info_backoff = 1205; // uint8 - uint32 tcp_info_options = 1206; // uint8 -// __u8 _snd_wscale : 4, _rcv_wscale : 4; -// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; - uint32 tcp_info_send_scale = 1207; // uint4 - uint32 tcp_info_rcv_scale = 1208; // uint4 - uint32 tcp_info_delivery_rate_app_limited = 1209; // uint8 - uint32 tcp_info_fast_open_client_failed = 1210; // uint8 - - uint32 tcp_info_rto = 1215; - uint32 tcp_info_ato = 1216; - uint32 tcp_info_snd_mss = 1217; - uint32 tcp_info_rcv_mss = 1218; - - uint32 tcp_info_unacked = 1219; - uint32 tcp_info_sacked = 1220; - uint32 tcp_info_lost = 1221; - uint32 tcp_info_retrans = 1222; - uint32 tcp_info_fackets = 1223; + // and tests don't trip staticcheck SA1019.) Free: 1100, 1105-1199. + uint32 mem_info_rmem = 1101; // struct inet_diag_meminfo.idiag_rmem (__u32) + uint32 mem_info_wmem = 1102; // struct inet_diag_meminfo.idiag_wmem (__u32) + uint32 mem_info_fmem = 1103; // struct inet_diag_meminfo.idiag_fmem (__u32) + uint32 mem_info_tmem = 1104; // struct inet_diag_meminfo.idiag_tmem (__u32) + + // ---- payload: struct tcp_info, INET_DIAG_INFO 2 (1200s) ------------------- + // Declared in struct order (tcp.h). The kernel appends members over time and + // DeserializeTCPInfo (pkg/xtcpnl) accepts every historical struct size, so + // members newer than the running kernel decode as 0. + // Free: 1200, 1211-1214, 1277-1299. 1266-1276 are PRE-ASSIGNED (see below). + uint32 tcp_info_state = 1201; // struct tcp_info.tcpi_state (__u8) + uint32 tcp_info_ca_state = 1202; // struct tcp_info.tcpi_ca_state (__u8) TCP_CA_Open..TCP_CA_Loss + uint32 tcp_info_retransmits = 1203; // struct tcp_info.tcpi_retransmits (__u8) + uint32 tcp_info_probes = 1204; // struct tcp_info.tcpi_probes (__u8) + uint32 tcp_info_backoff = 1205; // struct tcp_info.tcpi_backoff (__u8) + uint32 tcp_info_options = 1206; // struct tcp_info.tcpi_options (__u8) TCPI_OPT_* bitmask + uint32 tcp_info_snd_wscale = 1207; // struct tcp_info.tcpi_snd_wscale (__u8:4) + uint32 tcp_info_rcv_wscale = 1208; // struct tcp_info.tcpi_rcv_wscale (__u8:4) + uint32 tcp_info_delivery_rate_app_limited = 1209; // struct tcp_info.tcpi_delivery_rate_app_limited (__u8:1) + uint32 tcp_info_fastopen_client_fail = 1210; // struct tcp_info.tcpi_fastopen_client_fail (__u8:2) + + uint32 tcp_info_rto = 1215; // struct tcp_info.tcpi_rto (__u32) usec + uint32 tcp_info_ato = 1216; // struct tcp_info.tcpi_ato (__u32) usec + uint32 tcp_info_snd_mss = 1217; // struct tcp_info.tcpi_snd_mss (__u32) + uint32 tcp_info_rcv_mss = 1218; // struct tcp_info.tcpi_rcv_mss (__u32) + + uint32 tcp_info_unacked = 1219; // struct tcp_info.tcpi_unacked (__u32) + uint32 tcp_info_sacked = 1220; // struct tcp_info.tcpi_sacked (__u32) + uint32 tcp_info_lost = 1221; // struct tcp_info.tcpi_lost (__u32) + uint32 tcp_info_retrans = 1222; // struct tcp_info.tcpi_retrans (__u32) + uint32 tcp_info_fackets = 1223; // struct tcp_info.tcpi_fackets (__u32) // Times - uint32 tcp_info_last_data_sent = 1224; - uint32 tcp_info_last_ack_sent = 1225; - uint32 tcp_info_last_data_recv = 1226; - uint32 tcp_info_last_ack_recv = 1227; + uint32 tcp_info_last_data_sent = 1224; // struct tcp_info.tcpi_last_data_sent (__u32) ms ago + uint32 tcp_info_last_ack_sent = 1225; // struct tcp_info.tcpi_last_ack_sent (__u32) "Not remembered, sorry." (always 0) + uint32 tcp_info_last_data_recv = 1226; // struct tcp_info.tcpi_last_data_recv (__u32) ms ago + uint32 tcp_info_last_ack_recv = 1227; // struct tcp_info.tcpi_last_ack_recv (__u32) ms ago // Metrics - uint32 tcp_info_pmtu = 1228; - uint32 tcp_info_rcv_ssthresh = 1229; - uint32 tcp_info_rtt = 1230; - uint32 tcp_info_rtt_var = 1231; - uint32 tcp_info_snd_ssthresh = 1232; - uint32 tcp_info_snd_cwnd = 1233; - uint32 tcp_info_adv_mss = 1234; - uint32 tcp_info_reordering = 1235; - - uint32 tcp_info_rcv_rtt = 1236; - uint32 tcp_info_rcv_space = 1237; - - uint32 tcp_info_total_retrans = 1238; - - uint64 tcp_info_pacing_rate = 1239; - uint64 tcp_info_max_pacing_rate = 1240; - uint64 tcp_info_bytes_acked = 1241; // RFC4898 tcpEStatsAppHCThruOctetsAcked - uint64 tcp_info_bytes_received = 1242; // RFC4898 tcpEStatsAppHCThruOctetsReceived - uint32 tcp_info_segs_out = 1243; // RFC4898 tcpEStatsPerfSegsOut - uint32 tcp_info_segs_in = 1244; // RFC4898 tcpEStatsPerfSegsIn - - uint32 tcp_info_not_sent_bytes = 1245; - uint32 tcp_info_min_rtt = 1246; - uint32 tcp_info_data_segs_in = 1247; // RFC4898 tcpEStatsDataSegsIn - uint32 tcp_info_data_segs_out = 1248; // RFC4898 tcpEStatsDataSegsOut - - uint64 tcp_info_delivery_rate = 1249; - - uint64 tcp_info_busy_time = 1250; // Time (usec) busy sending data - uint64 tcp_info_rwnd_limited = 1251; // Time (usec) limited by receive window - uint64 tcp_info_sndbuf_limited = 1252; // Time (usec) limited by send buffer - - //4.15 kernel tcp_info ends here, 5+ below - - uint32 tcp_info_delivered = 1253; - uint32 tcp_info_delivered_ce = 1254; + uint32 tcp_info_pmtu = 1228; // struct tcp_info.tcpi_pmtu (__u32) + uint32 tcp_info_rcv_ssthresh = 1229; // struct tcp_info.tcpi_rcv_ssthresh (__u32) + uint32 tcp_info_rtt = 1230; // struct tcp_info.tcpi_rtt (__u32) smoothed RTT, usec + uint32 tcp_info_rttvar = 1231; // struct tcp_info.tcpi_rttvar (__u32) RTT variance, usec + uint32 tcp_info_snd_ssthresh = 1232; // struct tcp_info.tcpi_snd_ssthresh (__u32) + uint32 tcp_info_snd_cwnd = 1233; // struct tcp_info.tcpi_snd_cwnd (__u32) segments + uint32 tcp_info_advmss = 1234; // struct tcp_info.tcpi_advmss (__u32) + uint32 tcp_info_reordering = 1235; // struct tcp_info.tcpi_reordering (__u32) + + uint32 tcp_info_rcv_rtt = 1236; // struct tcp_info.tcpi_rcv_rtt (__u32) usec + uint32 tcp_info_rcv_space = 1237; // struct tcp_info.tcpi_rcv_space (__u32) + + uint32 tcp_info_total_retrans = 1238; // struct tcp_info.tcpi_total_retrans (__u32) + + uint64 tcp_info_pacing_rate = 1239; // struct tcp_info.tcpi_pacing_rate (__u64) bytes/sec + uint64 tcp_info_max_pacing_rate = 1240; // struct tcp_info.tcpi_max_pacing_rate (__u64) bytes/sec + uint64 tcp_info_bytes_acked = 1241; // struct tcp_info.tcpi_bytes_acked (__u64) RFC4898 tcpEStatsAppHCThruOctetsAcked + uint64 tcp_info_bytes_received = 1242; // struct tcp_info.tcpi_bytes_received (__u64) RFC4898 tcpEStatsAppHCThruOctetsReceived + uint32 tcp_info_segs_out = 1243; // struct tcp_info.tcpi_segs_out (__u32) RFC4898 tcpEStatsPerfSegsOut + uint32 tcp_info_segs_in = 1244; // struct tcp_info.tcpi_segs_in (__u32) RFC4898 tcpEStatsPerfSegsIn + + uint32 tcp_info_notsent_bytes = 1245; // struct tcp_info.tcpi_notsent_bytes (__u32) + uint32 tcp_info_min_rtt = 1246; // struct tcp_info.tcpi_min_rtt (__u32) usec + uint32 tcp_info_data_segs_in = 1247; // struct tcp_info.tcpi_data_segs_in (__u32) RFC4898 tcpEStatsDataSegsIn + uint32 tcp_info_data_segs_out = 1248; // struct tcp_info.tcpi_data_segs_out (__u32) RFC4898 tcpEStatsDataSegsOut + + uint64 tcp_info_delivery_rate = 1249; // struct tcp_info.tcpi_delivery_rate (__u64) bytes/sec + + uint64 tcp_info_busy_time = 1250; // struct tcp_info.tcpi_busy_time (__u64) usec busy sending data + uint64 tcp_info_rwnd_limited = 1251; // struct tcp_info.tcpi_rwnd_limited (__u64) usec limited by receive window + uint64 tcp_info_sndbuf_limited = 1252; // struct tcp_info.tcpi_sndbuf_limited (__u64) usec limited by send buffer + + // 4.15 kernel tcp_info ends here (192 bytes); 4.19+ below + uint32 tcp_info_delivered = 1253; // struct tcp_info.tcpi_delivered (__u32) + uint32 tcp_info_delivered_ce = 1254; // struct tcp_info.tcpi_delivered_ce (__u32) // https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB - uint64 tcp_info_bytes_sent = 1255; // RFC4898 tcpEStatsPerfHCDataOctetsOut - uint64 tcp_info_bytes_retrans = 1256; // RFC4898 tcpEStatsPerfOctetsRetrans - uint32 tcp_info_dsack_dups = 1257; // RFC4898 tcpEStatsStackDSACKDups - uint32 tcp_info_reord_seen = 1258; // reordering events seen - - uint32 tcp_info_rcv_ooopack = 1259; // Out-of-order packets received - - uint32 tcp_info_snd_wnd = 1260; // peer's advertised receive window after scaling (bytes) - uint32 tcp_info_rcv_wnd = 1261; // local advertised receive window after scaling (bytes) - uint32 tcp_info_rehash = 1262; // PLB or timeout triggered rehash attempts - uint32 tcp_info_total_rto = 1263; // Total number of RTO timeouts, including SYN/SYN-ACK and recurring timeouts - uint32 tcp_info_total_rto_recoveries = 1264; // Total number of RTO recoveries, including any unfinished recovery - uint32 tcp_info_total_rto_time = 1265; // Total time spent in RTO recoveries in milliseconds, including any unfinished recovery - - - // Please note it's recommended to use the enum for efficency, but keeping the string - // just in case we need to quickly put a different algorithm in without updating the enum. - // Obviously it's optional, so it low cost. - string congestion_algorithm_string = 1300; // INET_DIAG_CONG 4 + uint64 tcp_info_bytes_sent = 1255; // struct tcp_info.tcpi_bytes_sent (__u64) RFC4898 tcpEStatsPerfHCDataOctetsOut + uint64 tcp_info_bytes_retrans = 1256; // struct tcp_info.tcpi_bytes_retrans (__u64) RFC4898 tcpEStatsPerfOctetsRetrans + uint32 tcp_info_dsack_dups = 1257; // struct tcp_info.tcpi_dsack_dups (__u32) RFC4898 tcpEStatsStackDSACKDups + uint32 tcp_info_reord_seen = 1258; // struct tcp_info.tcpi_reord_seen (__u32) reordering events seen + + uint32 tcp_info_rcv_ooopack = 1259; // struct tcp_info.tcpi_rcv_ooopack (__u32) out-of-order packets received (5.4+) + + uint32 tcp_info_snd_wnd = 1260; // struct tcp_info.tcpi_snd_wnd (__u32) peer's advertised receive window after scaling, bytes + uint32 tcp_info_rcv_wnd = 1261; // struct tcp_info.tcpi_rcv_wnd (__u32) local advertised receive window after scaling, bytes (6.6+) + uint32 tcp_info_rehash = 1262; // struct tcp_info.tcpi_rehash (__u32) PLB or timeout triggered rehash attempts (6.6+) + uint32 tcp_info_total_rto = 1263; // struct tcp_info.tcpi_total_rto (__u16) RTO timeouts incl. SYN/SYN-ACK and recurring (6.10+) + uint32 tcp_info_total_rto_recoveries = 1264; // struct tcp_info.tcpi_total_rto_recoveries (__u16) RTO recoveries incl. any unfinished (6.10+) + uint32 tcp_info_total_rto_time = 1265; // struct tcp_info.tcpi_total_rto_time (__u32) ms in RTO recoveries incl. any unfinished (6.10+) + + // 6.10 kernel tcp_info ends here (248 bytes). PRE-ASSIGNED for the members + // added since (AccECN, Linux 6.13+ / 7.x, tcp.h); declare them when + // DeserializeTCPInfo learns the larger struct size and a matching nlmon + // fixture exists — do NOT hand these numbers to anything else: + // 1266 tcp_info_received_ce struct tcp_info.tcpi_received_ce (__u32) + // 1267 tcp_info_delivered_e1_bytes struct tcp_info.tcpi_delivered_e1_bytes (__u32) + // 1268 tcp_info_delivered_e0_bytes struct tcp_info.tcpi_delivered_e0_bytes (__u32) + // 1269 tcp_info_delivered_ce_bytes struct tcp_info.tcpi_delivered_ce_bytes (__u32) + // 1270 tcp_info_received_e1_bytes struct tcp_info.tcpi_received_e1_bytes (__u32) + // 1271 tcp_info_received_e0_bytes struct tcp_info.tcpi_received_e0_bytes (__u32) + // 1272 tcp_info_received_ce_bytes struct tcp_info.tcpi_received_ce_bytes (__u32) + // 1273 tcp_info_ecn_mode struct tcp_info.tcpi_ecn_mode (__u32:2) + // 1274 tcp_info_accecn_opt_seen struct tcp_info.tcpi_accecn_opt_seen (__u32:2) + // 1275 tcp_info_accecn_fail_mode struct tcp_info.tcpi_accecn_fail_mode (__u32:4) + // 1276 tcp_info_options2 struct tcp_info.tcpi_options2 (__u32:24) + + // ---- payload: INET_DIAG_CONG 4 (1300s) ------------------------------------ + // The kernel emits the congestion-control module name as a NUL-terminated + // string (nla_put_string(skb, INET_DIAG_CONG, ca_ops->name), inet_diag.c). + // It's recommended to use the enum for efficiency, but the string is kept so + // an algorithm the enum does not know yet is still visible. Free: 1302-1399. + string inet_diag_cong = 1300; // INET_DIAG_CONG (4): ca_ops->name (char[TCP_CA_NAME_MAX=16], inet_diag.c) enum CongestionAlgorithm { CONGESTION_ALGORITHM_UNSPECIFIED = 0; CONGESTION_ALGORITHM_CUBIC = 1; @@ -321,51 +437,63 @@ message XtcpFlatRecord { CONGESTION_ALGORITHM_BBR2 = 6; CONGESTION_ALGORITHM_BBR3 = 7; }; - CongestionAlgorithm congestion_algorithm_enum = 1301; // INET_DIAG_CONG 4 - - uint32 type_of_service = 1401; // INET_DIAG_TOS 5 uint8 - uint32 traffic_class = 1402; // INET_DIAG_TCLASS 6 uint8 - - // sk_mem_info sk_mem_info = 1500; // INET_DIAG_SKMEMINFO 7 - - uint32 sk_mem_info_rmem_alloc = 1501; - uint32 sk_mem_info_rcv_buf = 1502; - uint32 sk_mem_info_wmem_alloc = 1503; - uint32 sk_mem_info_snd_buf = 1504; - uint32 sk_mem_info_fwd_alloc = 1505; - uint32 sk_mem_info_wmem_queued = 1506; - uint32 sk_mem_info_optmem = 1507; - uint32 sk_mem_info_backlog = 1508; - uint32 sk_mem_info_drops = 1509; - - uint32 shutdown_state = 1600; // UNIX_DIAG_SHUTDOWN 8uint8 - - // vegas_info vegas_info = 1700; // INET_DIAG_VEGASINFO - - uint32 vegas_info_enabled = 1701; - uint32 vegas_info_rtt_cnt = 1702; - uint32 vegas_info_rtt = 1703; - uint32 vegas_info_min_rtt = 1704; - - // dctcp_info dctcp_info = 1800; // INET_DIAG_DCTCPINFO - - uint32 dctcp_info_enabled = 1801; - uint32 dctcp_info_ce_state = 1802; - uint32 dctcp_info_alpha = 1803; - uint32 dctcp_info_ab_ecn = 1804; - uint32 dctcp_info_ab_tot = 1805; - - // bbr_info bbr_info = 1900; // INET_DIAG_BBRINFO 16 - - uint32 bbr_info_bw_lo = 1901; - uint32 bbr_info_bw_hi = 1902; - uint32 bbr_info_min_rtt = 1903; - uint32 bbr_info_pacing_gain = 1904; - uint32 bbr_info_cwnd_gain = 1905; - - uint32 class_id = 2001; // INET_DIAG_CLASS_ID 17 uint32 - uint32 sock_opt = 2002; // INET_DIAG_SOCKOPT - uint64 c_group = 2103; // INET_DIAG_BC_CGROUP_COND + CongestionAlgorithm inet_diag_cong_enum = 1301; // derived by xtcp from inet_diag_cong (not a kernel field) + + // ---- payload: INET_DIAG_TOS 5 / INET_DIAG_TCLASS 6 (1400s) ---------------- + // Free: 1400, 1403-1499. + uint32 inet_diag_tos = 1401; // INET_DIAG_TOS (5): inet->tos (__u8, inet_diag.c) IPv4 TOS byte + uint32 inet_diag_tclass = 1402; // INET_DIAG_TCLASS (6): np->tclass (__u8, inet_diag.c) IPv6 traffic class + + // ---- payload: SK_MEMINFO_*, INET_DIAG_SKMEMINFO 7 (1500s) ----------------- + // __u32 mem[SK_MEMINFO_VARS] filled by sk_get_meminfo (net/core/sock.c), + // indexed by enum sock_diag.h SK_MEMINFO_*. Free: 1500, 1510-1599. + uint32 sk_mem_info_rmem_alloc = 1501; // SK_MEMINFO_RMEM_ALLOC (__u32, sock_diag.h) sk_rmem_alloc + uint32 sk_mem_info_rcvbuf = 1502; // SK_MEMINFO_RCVBUF (__u32, sock_diag.h) sk_rcvbuf + uint32 sk_mem_info_wmem_alloc = 1503; // SK_MEMINFO_WMEM_ALLOC (__u32, sock_diag.h) sk_wmem_alloc + uint32 sk_mem_info_sndbuf = 1504; // SK_MEMINFO_SNDBUF (__u32, sock_diag.h) sk_sndbuf + uint32 sk_mem_info_fwd_alloc = 1505; // SK_MEMINFO_FWD_ALLOC (__u32, sock_diag.h) sk_forward_alloc + uint32 sk_mem_info_wmem_queued = 1506; // SK_MEMINFO_WMEM_QUEUED (__u32, sock_diag.h) sk_wmem_queued + uint32 sk_mem_info_optmem = 1507; // SK_MEMINFO_OPTMEM (__u32, sock_diag.h) sk_omem_alloc + uint32 sk_mem_info_backlog = 1508; // SK_MEMINFO_BACKLOG (__u32, sock_diag.h) sk_backlog.len + uint32 sk_mem_info_drops = 1509; // SK_MEMINFO_DROPS (__u32, sock_diag.h) sk_drops + + // ---- payload: INET_DIAG_SHUTDOWN 8 (1600s) -------------------------------- + // Free: 1601-1699. + uint32 inet_diag_shutdown = 1600; // INET_DIAG_SHUTDOWN (8): sk->sk_shutdown (__u8, inet_diag.c) RCV_SHUTDOWN=1|SEND_SHUTDOWN=2 + + // ---- payload: struct tcpvegas_info, INET_DIAG_VEGASINFO 3 (1700s) --------- + // Only present when the socket's CC module is vegas (tcp_vegas.c + // tcp_vegas_get_info). Free: 1700, 1705-1799. + uint32 vegas_info_enabled = 1701; // struct tcpvegas_info.tcpv_enabled (__u32) + uint32 vegas_info_rttcnt = 1702; // struct tcpvegas_info.tcpv_rttcnt (__u32) + uint32 vegas_info_rtt = 1703; // struct tcpvegas_info.tcpv_rtt (__u32) usec + uint32 vegas_info_minrtt = 1704; // struct tcpvegas_info.tcpv_minrtt (__u32) usec + + // ---- payload: struct tcp_dctcp_info, INET_DIAG_DCTCPINFO 9 (1800s) -------- + // Only present when the socket's CC module is dctcp (tcp_dctcp.c + // dctcp_get_info); requested via the VEGASINFO bit. Free: 1800, 1806-1899. + uint32 dctcp_info_enabled = 1801; // struct tcp_dctcp_info.dctcp_enabled (__u16) + uint32 dctcp_info_ce_state = 1802; // struct tcp_dctcp_info.dctcp_ce_state (__u16) + uint32 dctcp_info_alpha = 1803; // struct tcp_dctcp_info.dctcp_alpha (__u32) + uint32 dctcp_info_ab_ecn = 1804; // struct tcp_dctcp_info.dctcp_ab_ecn (__u32) + uint32 dctcp_info_ab_tot = 1805; // struct tcp_dctcp_info.dctcp_ab_tot (__u32) + + // ---- payload: struct tcp_bbr_info, INET_DIAG_BBRINFO 16 (1900s) ----------- + // Only present when the socket's CC module is bbr (tcp_bbr.c bbr_get_info); + // requested via the VEGASINFO bit. Free: 1900, 1906-1999. + uint32 bbr_info_bw_lo = 1901; // struct tcp_bbr_info.bbr_bw_lo (__u32) lower 32 bits of bw, bytes/sec + uint32 bbr_info_bw_hi = 1902; // struct tcp_bbr_info.bbr_bw_hi (__u32) upper 32 bits of bw + uint32 bbr_info_min_rtt = 1903; // struct tcp_bbr_info.bbr_min_rtt (__u32) min-filtered RTT, usec + uint32 bbr_info_pacing_gain = 1904; // struct tcp_bbr_info.bbr_pacing_gain (__u32) pacing gain << 8 + uint32 bbr_info_cwnd_gain = 1905; // struct tcp_bbr_info.bbr_cwnd_gain (__u32) cwnd gain << 8 + + // ---- payload: socket classification attributes (2000s) -------------------- + // INET_DIAG_CLASS_ID 17, INET_DIAG_SOCKOPT 22, INET_DIAG_CGROUP_ID 21 — the + // per-socket scalars inet_diag_msg_attrs_fill emits after the CC extensions. + // Free: 2000, 2004-2099. Next free block: 2100. + uint32 inet_diag_class_id = 2001; // INET_DIAG_CLASS_ID (17): classid (__u32, inet_diag.c) net_cls cgroup classid, else sk->sk_priority + uint32 inet_diag_sockopt = 2002; // INET_DIAG_SOCKOPT (22): struct inet_diag_sockopt (2 x __u8 bitfields, inet_diag.h) packed little-endian u16: recverr,is_icsk,freebind,hdrincl,mc_loop,transparent,mc_all,nodefrag | bind_address_no_port,recverr_rfc4884,defer_connect + uint64 inet_diag_cgroup_id = 2003; // INET_DIAG_CGROUP_ID (21): cgroup_id(sock_cgroup_ptr(&sk->sk_cgrp_data)) (__u64, inet_diag.c) cgroup v2 id }; service XTCPFlatRecordService { @@ -383,7 +511,6 @@ message FlatRecordsRequest { message FlatRecordsResponse { XtcpFlatRecord xtcp_flat_record = 1; - // Envelope.XtcpFlatRecord xtcp_flat_record = 1; } message PollFlatRecordsRequest { @@ -392,7 +519,6 @@ message PollFlatRecordsRequest { message PollFlatRecordsResponse { XtcpFlatRecord xtcp_flat_record = 1; - // Envelope.XtcpFlatRecord xtcp_flat_record = 1; } -// end \ No newline at end of file +// end diff --git a/build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto b/build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto deleted file mode 100644 index c2bbee8..0000000 --- a/build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto +++ /dev/null @@ -1,477 +0,0 @@ -// -// xTCP - eXport TCP Inet Diagnostic messages -// -// These are all the structs relating to the TCP diagnotic module in the kernel -// -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 -// -// There are links to the kernel source showing where the struct came from. -// -// Build this using buf build ( https://buf.build/ ), see the buf config in the root folder - -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto - -// https://protobuf.dev/programming-guides/encoding/#structure - -syntax = "proto3"; - -package xtcp_flat_record_repeated.v1; - -// https://developers.google.com/protocol-buffers/docs/reference/go-generated -// option go_package = "github.com/randomizedcoder/xtcp2/pkg/xtcppb"; -// option go_package = "github.com/randomizedcoder/xtcp"; -option go_package = "./pkg/xtcp_flat_record"; - -// https://github.com/bufbuild/protovalidate -// https://buf.build/bufbuild/protovalidate/docs/main:buf.validate -// https://github.com/bufbuild/protovalidate/tree/main/examples -// https://buf.build/docs/lint/rules/?h=protovalidate#protovalidate -// import "buf/validate/validate.proto"; - -service XTCPFlatRecordService { - - // If xtcp is polling, this will return the stream - rpc FlatRecords ( FlatRecordsRequest ) returns ( stream FlatRecordsResponse ); - - // If xtcp is not polling, this allows the client to send a poll request - rpc PollFlatRecords ( stream PollFlatRecordsRequest ) returns ( stream FlatRecordsResponse ); -} - -message FlatRecordsRequest { - // empty -} - -message FlatRecordsResponse { - XtcpFlatRecord xtcp_flat_record = 1; -} - -message PollFlatRecordsRequest { - // empty -} - -// message PollFlatRecordsResponse { -// XtcpFlatRecord xtcp_flat_record = 1; -// } - -// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information -message XtcpFlatRecord { - double timestamp_ns = 10; - - // uint64 sec = 11; - // uint64 nsec = 12; - - string hostname = 20; - - // network namespace - string netns = 30; - - // network namespace id - // TODO xtcp does not currently get the id - uint32 nsid = 40; - - // free form string - string label = 50; - - // free form string - string tag = 60; - - uint64 record_counter = 70; - - uint64 socket_fd = 80; - - uint64 netlinker_id = 90; - - // inet_diag_msg inet_diag_msg = 100; - - uint32 inet_diag_msg_family = 101; // uint8 - uint32 inet_diag_msg_state = 102; // uint8 - uint32 inet_diag_msg_timer = 103; // uint8 - uint32 inet_diag_msg_retrans = 104; // uint8 - - uint32 inet_diag_msg_socket_source_port = 105; // __be16 - uint32 inet_diag_msg_socket_destination_port = 106; // __be16 - bytes inet_diag_msg_socket_source = 107; - bytes inet_diag_msg_socket_destination = 108; - uint32 inet_diag_msg_socket_interface = 109; - uint64 inet_diag_msg_socket_cookie = 110; // [2]uint32 - uint64 inet_diag_msg_socket_dest_asn = 111; - uint64 inet_diag_msg_socket_next_hop_asn = 112; - - uint32 inet_diag_msg_expires = 113; - uint32 inet_diag_msg_rqueue = 114; - uint32 inet_diag_msg_wqueue = 115; - uint32 inet_diag_msg_uid = 116; - uint32 inet_diag_msg_inode = 117; - - // might want to put more here - // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 - // mem_info mem_info = 200; // INET_DIAG_MEMINFO 1 - - uint32 mem_info_rmem = 201; - uint32 mem_info_wmem = 202; - uint32 mem_info_fmem = 203; - uint32 mem_info_tmem = 204; - - //tcp_info tcp_info = 300; // INET_DIAG_INFO 2 - - uint32 tcp_info_state = 301; // uint8 - uint32 tcp_info_ca_state = 302; // uint8 - uint32 tcp_info_retransmits = 303; // uint8 - uint32 tcp_info_probes = 304; // uint8 - uint32 tcp_info_backoff = 305; // uint8 - uint32 tcp_info_options = 306; // uint8 -// __u8 _snd_wscale : 4, _rcv_wscale : 4; -// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; - uint32 tcp_info_send_scale = 307; // uint4 - uint32 tcp_info_rcv_scale = 308; // uint4 - uint32 tcp_info_delivery_rate_app_limited = 309; // uint8 - uint32 tcp_info_fast_open_client_failed = 310; // uint8 - - uint32 tcp_info_rto = 315; - uint32 tcp_info_ato = 316; - uint32 tcp_info_snd_mss = 317; - uint32 tcp_info_rcv_mss = 318; - - uint32 tcp_info_unacked = 319; - uint32 tcp_info_sacked = 320; - uint32 tcp_info_lost = 321; - uint32 tcp_info_retrans = 322; - uint32 tcp_info_fackets = 323; - - // Times - uint32 tcp_info_last_data_sent = 324; - uint32 tcp_info_last_ack_sent = 325; - uint32 tcp_info_last_data_recv = 326; - uint32 tcp_info_last_ack_recv = 327; - - // Metrics - uint32 tcp_info_pmtu = 328; - uint32 tcp_info_rcv_ssthresh = 329; - uint32 tcp_info_rtt = 330; - uint32 tcp_info_rtt_var = 331; - uint32 tcp_info_snd_ssthresh = 332; - uint32 tcp_info_snd_cwnd = 333; - uint32 tcp_info_adv_mss = 334; - uint32 tcp_info_reordering = 335; - - uint32 tcp_info_rcv_rtt = 336; - uint32 tcp_info_rcv_space = 337; - - uint32 tcp_info_total_retrans = 338; - - uint64 tcp_info_pacing_rate = 339; - uint64 tcp_info_max_pacing_rate = 340; - uint64 tcp_info_bytes_acked = 341; // RFC4898 tcpEStatsAppHCThruOctetsAcked - uint64 tcp_info_bytes_received = 342; // RFC4898 tcpEStatsAppHCThruOctetsReceived - uint32 tcp_info_segs_out = 343; // RFC4898 tcpEStatsPerfSegsOut - uint32 tcp_info_segs_in = 344; // RFC4898 tcpEStatsPerfSegsIn - - uint32 tcp_info_not_sent_bytes = 345; - uint32 tcp_info_min_rtt = 346; - uint32 tcp_info_data_segs_in = 347; // RFC4898 tcpEStatsDataSegsIn - uint32 tcp_info_data_segs_out = 348; // RFC4898 tcpEStatsDataSegsOut - - uint64 tcp_info_delivery_rate = 349; - - uint64 tcp_info_busy_time = 350; // Time (usec) busy sending data - uint64 tcp_info_rwnd_limited = 351; // Time (usec) limited by receive window - uint64 tcp_info_sndbuf_limited = 352; // Time (usec) limited by send buffer - - //4.15 kernel tcp_info ends here, 5+ below - - uint32 tcp_info_delivered = 353; - uint32 tcp_info_delivered_ce = 354; - - // https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB - uint64 tcp_info_bytes_sent = 355; // RFC4898 tcpEStatsPerfHCDataOctetsOut - uint64 tcp_info_bytes_retrans = 356; // RFC4898 tcpEStatsPerfOctetsRetrans - uint32 tcp_info_dsack_dups = 357; // RFC4898 tcpEStatsStackDSACKDups - uint32 tcp_info_reord_seen = 358; // reordering events seen - - uint32 tcp_info_rcv_ooopack = 359; // Out-of-order packets received - - uint32 tcp_info_snd_wnd = 360; // peer's advertised receive window after scaling (bytes) - uint32 tcp_info_rcv_wnd = 361; // local advertised receive window after scaling (bytes) - uint32 tcp_info_rehash = 362; // PLB or timeout triggered rehash attempts - uint32 tcp_info_total_rto = 363; // Total number of RTO timeouts, including SYN/SYN-ACK and recurring timeouts - uint32 tcp_info_total_rto_recoveries = 364; // Total number of RTO recoveries, including any unfinished recovery - uint32 tcp_info_total_rto_time = 365; // Total time spent in RTO recoveries in milliseconds, including any unfinished recovery - - - // Please note it's recommended to use the enum for efficency, but keeping the string - // just in case we need to quickly put a different algorithm in without updating the enum. - // Obviously it's optional, so it low cost. - string congestion_algorithm_string = 400; // INET_DIAG_CONG 4 - enum CongestionAlgorithm { - CONGESTION_ALGORITHM_UNSPECIFIED = 0; - CONGESTION_ALGORITHM_CUBIC = 1; - CONGESTION_ALGORITHM_DCTCP = 2; - CONGESTION_ALGORITHM_VEGAS = 3; - CONGESTION_ALGORITHM_PRAGUE = 4; - CONGESTION_ALGORITHM_BBR1 = 5; - CONGESTION_ALGORITHM_BBR2 = 6; - CONGESTION_ALGORITHM_BBR3 = 7; - }; - CongestionAlgorithm congestion_algorithm_enum = 401; // INET_DIAG_CONG 4 - - uint32 type_of_service = 501; // INET_DIAG_TOS 5 uint8 - uint32 traffic_class = 502; // INET_DIAG_TCLASS 6 uint8 - - // sk_mem_info sk_mem_info = 600; // INET_DIAG_SKMEMINFO 7 - - uint32 sk_mem_info_rmem_alloc = 601; - uint32 sk_mem_info_rcv_buf = 602; - uint32 sk_mem_info_wmem_alloc = 603; - uint32 sk_mem_info_snd_buf = 604; - uint32 sk_mem_info_fwd_alloc = 605; - uint32 sk_mem_info_wmem_queued = 606; - uint32 sk_mem_info_optmem = 607; - uint32 sk_mem_info_backlog = 608; - uint32 sk_mem_info_drops = 609; - - uint32 shutdown_state = 700; // UNIX_DIAG_SHUTDOWN 8uint8 - - // vegas_info vegas_info = 800; // INET_DIAG_VEGASINFO - - uint32 vegas_info_enabled = 801; - uint32 vegas_info_rtt_cnt = 802; - uint32 vegas_info_rtt = 803; - uint32 vegas_info_min_rtt = 804; - - // dctcp_info dctcp_info = 900; // INET_DIAG_DCTCPINFO - - uint32 dctcp_info_enabled = 901; - uint32 dctcp_info_ce_state = 902; - uint32 dctcp_info_alpha = 903; - uint32 dctcp_info_ab_ecn = 904; - uint32 dctcp_info_ab_tot = 905; - - // bbr_info bbr_info = 1000; // INET_DIAG_BBRINFO 16 - - uint32 bbr_info_bw_lo = 1001; - uint32 bbr_info_bw_hi = 1002; - uint32 bbr_info_min_rtt = 1003; - uint32 bbr_info_pacing_gain = 1004; - uint32 bbr_info_cwnd_gain = 1005; - - uint32 class_id = 1101; // INET_DIAG_CLASS_ID 17 uint32 - uint32 sock_opt = 1102; // INET_DIAG_SOCKOPT - uint64 c_group = 1203; // INET_DIAG_BC_CGROUP_COND -}; - -// https://clickhouse.com/docs/en/interfaces/formats#protobuflist -message Envelope { - - message XtcpFlatRecord { - double timestamp_ns = 10; - - // uint64 sec = 11; - // uint64 nsec = 12; - - string hostname = 20; - - // network namespace - string netns = 30; - - // network namespace id - // TODO xtcp does not currently get the id - uint32 nsid = 40; - - // free form string - string label = 50; - - // free form string - string tag = 60; - - uint64 record_counter = 70; - - uint64 socket_fd = 80; - - uint64 netlinker_id = 90; - - // inet_diag_msg inet_diag_msg = 100; - - uint32 inet_diag_msg_family = 101; // uint8 - uint32 inet_diag_msg_state = 102; // uint8 - uint32 inet_diag_msg_timer = 103; // uint8 - uint32 inet_diag_msg_retrans = 104; // uint8 - - uint32 inet_diag_msg_socket_source_port = 105; // __be16 - uint32 inet_diag_msg_socket_destination_port = 106; // __be16 - bytes inet_diag_msg_socket_source = 107; - bytes inet_diag_msg_socket_destination = 108; - uint32 inet_diag_msg_socket_interface = 109; - uint64 inet_diag_msg_socket_cookie = 110; // [2]uint32 - uint64 inet_diag_msg_socket_dest_asn = 111; - uint64 inet_diag_msg_socket_next_hop_asn = 112; - - uint32 inet_diag_msg_expires = 113; - uint32 inet_diag_msg_rqueue = 114; - uint32 inet_diag_msg_wqueue = 115; - uint32 inet_diag_msg_uid = 116; - uint32 inet_diag_msg_inode = 117; - - // might want to put more here - // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 - // mem_info mem_info = 200; // INET_DIAG_MEMINFO 1 - - uint32 mem_info_rmem = 201; - uint32 mem_info_wmem = 202; - uint32 mem_info_fmem = 203; - uint32 mem_info_tmem = 204; - - //tcp_info tcp_info = 300; // INET_DIAG_INFO 2 - - uint32 tcp_info_state = 301; // uint8 - uint32 tcp_info_ca_state = 302; // uint8 - uint32 tcp_info_retransmits = 303; // uint8 - uint32 tcp_info_probes = 304; // uint8 - uint32 tcp_info_backoff = 305; // uint8 - uint32 tcp_info_options = 306; // uint8 - // __u8 _snd_wscale : 4, _rcv_wscale : 4; - // __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; - uint32 tcp_info_send_scale = 307; // uint4 - uint32 tcp_info_rcv_scale = 308; // uint4 - uint32 tcp_info_delivery_rate_app_limited = 309; // uint8 - uint32 tcp_info_fast_open_client_failed = 310; // uint8 - - uint32 tcp_info_rto = 315; - uint32 tcp_info_ato = 316; - uint32 tcp_info_snd_mss = 317; - uint32 tcp_info_rcv_mss = 318; - - uint32 tcp_info_unacked = 319; - uint32 tcp_info_sacked = 320; - uint32 tcp_info_lost = 321; - uint32 tcp_info_retrans = 322; - uint32 tcp_info_fackets = 323; - - // Times - uint32 tcp_info_last_data_sent = 324; - uint32 tcp_info_last_ack_sent = 325; - uint32 tcp_info_last_data_recv = 326; - uint32 tcp_info_last_ack_recv = 327; - - // Metrics - uint32 tcp_info_pmtu = 328; - uint32 tcp_info_rcv_ssthresh = 329; - uint32 tcp_info_rtt = 330; - uint32 tcp_info_rtt_var = 331; - uint32 tcp_info_snd_ssthresh = 332; - uint32 tcp_info_snd_cwnd = 333; - uint32 tcp_info_adv_mss = 334; - uint32 tcp_info_reordering = 335; - - uint32 tcp_info_rcv_rtt = 336; - uint32 tcp_info_rcv_space = 337; - - uint32 tcp_info_total_retrans = 338; - - uint64 tcp_info_pacing_rate = 339; - uint64 tcp_info_max_pacing_rate = 340; - uint64 tcp_info_bytes_acked = 341; // RFC4898 tcpEStatsAppHCThruOctetsAcked - uint64 tcp_info_bytes_received = 342; // RFC4898 tcpEStatsAppHCThruOctetsReceived - uint32 tcp_info_segs_out = 343; // RFC4898 tcpEStatsPerfSegsOut - uint32 tcp_info_segs_in = 344; // RFC4898 tcpEStatsPerfSegsIn - - uint32 tcp_info_not_sent_bytes = 345; - uint32 tcp_info_min_rtt = 346; - uint32 tcp_info_data_segs_in = 347; // RFC4898 tcpEStatsDataSegsIn - uint32 tcp_info_data_segs_out = 348; // RFC4898 tcpEStatsDataSegsOut - - uint64 tcp_info_delivery_rate = 349; - - uint64 tcp_info_busy_time = 350; // Time (usec) busy sending data - uint64 tcp_info_rwnd_limited = 351; // Time (usec) limited by receive window - uint64 tcp_info_sndbuf_limited = 352; // Time (usec) limited by send buffer - - //4.15 kernel tcp_info ends here, 5+ below - - uint32 tcp_info_delivered = 353; - uint32 tcp_info_delivered_ce = 354; - - // https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB - uint64 tcp_info_bytes_sent = 355; // RFC4898 tcpEStatsPerfHCDataOctetsOut - uint64 tcp_info_bytes_retrans = 356; // RFC4898 tcpEStatsPerfOctetsRetrans - uint32 tcp_info_dsack_dups = 357; // RFC4898 tcpEStatsStackDSACKDups - uint32 tcp_info_reord_seen = 358; // reordering events seen - - uint32 tcp_info_rcv_ooopack = 359; // Out-of-order packets received - - uint32 tcp_info_snd_wnd = 360; // peer's advertised receive window after scaling (bytes) - uint32 tcp_info_rcv_wnd = 361; // local advertised receive window after scaling (bytes) - uint32 tcp_info_rehash = 362; // PLB or timeout triggered rehash attempts - uint32 tcp_info_total_rto = 363; // Total number of RTO timeouts, including SYN/SYN-ACK and recurring timeouts - uint32 tcp_info_total_rto_recoveries = 364; // Total number of RTO recoveries, including any unfinished recovery - uint32 tcp_info_total_rto_time = 365; // Total time spent in RTO recoveries in milliseconds, including any unfinished recovery - - - // Please note it's recommended to use the enum for efficency, but keeping the string - // just in case we need to quickly put a different algorithm in without updating the enum. - // Obviously it's optional, so it low cost. - string congestion_algorithm_string = 400; // INET_DIAG_CONG 4 - enum CongestionAlgorithm { - CONGESTION_ALGORITHM_UNSPECIFIED = 0; - CONGESTION_ALGORITHM_CUBIC = 1; - CONGESTION_ALGORITHM_DCTCP = 2; - CONGESTION_ALGORITHM_VEGAS = 3; - CONGESTION_ALGORITHM_PRAGUE = 4; - CONGESTION_ALGORITHM_BBR1 = 5; - CONGESTION_ALGORITHM_BBR2 = 6; - CONGESTION_ALGORITHM_BBR3 = 7; - }; - CongestionAlgorithm congestion_algorithm_enum = 401; // INET_DIAG_CONG 4 - - uint32 type_of_service = 501; // INET_DIAG_TOS 5 uint8 - uint32 traffic_class = 502; // INET_DIAG_TCLASS 6 uint8 - - // sk_mem_info sk_mem_info = 600; // INET_DIAG_SKMEMINFO 7 - - uint32 sk_mem_info_rmem_alloc = 601; - uint32 sk_mem_info_rcv_buf = 602; - uint32 sk_mem_info_wmem_alloc = 603; - uint32 sk_mem_info_snd_buf = 604; - uint32 sk_mem_info_fwd_alloc = 605; - uint32 sk_mem_info_wmem_queued = 606; - uint32 sk_mem_info_optmem = 607; - uint32 sk_mem_info_backlog = 608; - uint32 sk_mem_info_drops = 609; - - uint32 shutdown_state = 700; // UNIX_DIAG_SHUTDOWN 8uint8 - - // vegas_info vegas_info = 800; // INET_DIAG_VEGASINFO - - uint32 vegas_info_enabled = 801; - uint32 vegas_info_rtt_cnt = 802; - uint32 vegas_info_rtt = 803; - uint32 vegas_info_min_rtt = 804; - - // dctcp_info dctcp_info = 900; // INET_DIAG_DCTCPINFO - - uint32 dctcp_info_enabled = 901; - uint32 dctcp_info_ce_state = 902; - uint32 dctcp_info_alpha = 903; - uint32 dctcp_info_ab_ecn = 904; - uint32 dctcp_info_ab_tot = 905; - - // bbr_info bbr_info = 1000; // INET_DIAG_BBRINFO 16 - - uint32 bbr_info_bw_lo = 1001; - uint32 bbr_info_bw_hi = 1002; - uint32 bbr_info_min_rtt = 1003; - uint32 bbr_info_pacing_gain = 1004; - uint32 bbr_info_cwnd_gain = 1005; - - uint32 class_id = 1101; // INET_DIAG_CLASS_ID 17 uint32 - uint32 sock_opt = 1102; // INET_DIAG_SOCKOPT - uint64 c_group = 1203; // INET_DIAG_BC_CGROUP_COND - }; - - repeated XtcpFlatRecord row = 10; -}; - -// end \ No newline at end of file diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql index f432357..ff35bc3 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql @@ -18,16 +18,28 @@ -- Per-version routing. Rows are fanned out by schema_version (see the versioned -- MVs in xtcp_xtcp_flat_records_mv.sql) into: -- xtcp.xtcp_flat_records_v0 — legacy / pre-versioning rows (schema_version = 0) --- xtcp.xtcp_flat_records_v1 — current format (schema_version = 1) +-- xtcp.xtcp_flat_records_v1 — epoch 1 (schema_version = 1); same columns as _v0 +-- xtcp.xtcp_flat_records_v2 — current format (schema_version = 2): payload +-- columns renamed to kernel struct spelling, +-- enrichment block regrouped. See +-- docs/record-versioning.md for the rename table. -- xtcp.xtcp_flat_records is a Merge view over ^xtcp_flat_records_v[0-9]+$ so -- existing queries/dashboards that hit xtcp_flat_records transparently span every --- version. Adding a future epoch = add a _vN table (CREATE ... AS _v0) + a _vN MV; --- the Merge regex picks it up with no edit here. _v1 is created "AS _v0" so the two --- physical tables can never drift. +-- version. The Merge view is declared AS _v2 (the current, superset column set); +-- columns that do not exist in an older _vN table read as defaults for that +-- table's rows, so branch on schema_version when a renamed column matters. +-- +-- Adding a future epoch: bump XtcpFlatRecordSchemaVersion, add a _vN table with +-- its own full DDL (AS _v(N-1) only if nothing was renamed), add a _vN MV, and +-- re-declare the Merge view AS the newest table. The Merge regex needs no edit. +-- +-- The v0/v1 DDL below is frozen: it must keep the epoch-0/1 column names because +-- xtcp_xtcp_flat_records_mv.sql aliases the v2 Kafka columns onto them by NAME. DROP TABLE IF EXISTS xtcp.xtcp_flat_records; DROP TABLE IF EXISTS xtcp.xtcp_flat_records_v0; DROP TABLE IF EXISTS xtcp.xtcp_flat_records_v1; +DROP TABLE IF EXISTS xtcp.xtcp_flat_records_v2; CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 ( @@ -38,8 +50,7 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 -- ---- metadata: record format provenance (1-2) -------------------------- -- schema_version is the routing epoch (0 = legacy); daemon_version is build - -- provenance. Placed right after timestamp_ns to match the Kafka table + - -- positional MV expansion. + -- provenance. schema_version UInt32 CODEC(LZ4), daemon_version LowCardinality(String), @@ -101,6 +112,22 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 uplink2_lldp_port_id LowCardinality(String), uplink2_lldp_port_descr LowCardinality(String), + -- ---- enrichment: daemon-computed fields (300s) -------------------------- + -- NOT read from the kernel inet_diag message; computed during enrichment + -- (rtnetlink address/route/link discovery, ipfeed ASN feeds). Empty/zero + -- when the relevant enricher is disabled or had no answer. + enrich_socket_interface_name LowCardinality(String), + enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4), + enrich_socket_dest_egress_ifname LowCardinality(String), + enrich_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'local_subnet' = 2, + 'remote' = 3 + ), + enrich_socket_dest_asn UInt64 CODEC(LZ4), + enrich_socket_next_hop_asn UInt64 CODEC(LZ4), + enrich_socket_dest_network_owner LowCardinality(String), + inet_diag_msg_family UInt32 CODEC(LZ4), inet_diag_msg_state UInt32 CODEC(LZ4), -- inet_diag_msg_family LowCardinality(UInt32), @@ -114,14 +141,6 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 inet_diag_msg_socket_destination String CODEC(ZSTD), inet_diag_msg_socket_interface UInt32 CODEC(LZ4), inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), - inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), - inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), - inet_diag_msg_socket_dest_network_owner LowCardinality(String), - inet_diag_msg_socket_dest_locality Enum('unspecified' = 0, - 'self' = 1, - 'connected_subnet' = 2, - 'remote' = 3 - ), inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), @@ -273,15 +292,262 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v0 TTL toDateTime(timestamp_ns) + INTERVAL 1 MONTH DELETE; --TTL toDateTime(sec) + INTERVAL 2 MONTH DELETE; --- Current-format table: identical structure/engine/ORDER BY/TTL to _v0 (so the two --- physical tables can never drift), differing only in which rows the MVs route here. +-- Epoch-1 table: identical structure/engine/ORDER BY/TTL to _v0 (the epoch-1 +-- format only added fields in free slots, no renames), differing only in which +-- rows the MVs route here. CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v1 AS xtcp.xtcp_flat_records_v0; +-- Epoch-2 table (current). Full DDL, NOT "AS _v0": epoch 2 renamed 18 payload +-- columns to the kernel struct member spelling (tcp_info_rtt_var -> +-- tcp_info_rttvar, c_group -> inet_diag_cgroup_id, ...), renamed +-- enrich_socket_next_hop_asn -> enrich_socket_dest_next_hop_asn, and reordered +-- the enrichment block. Column order matches proto field-number order in +-- proto/xtcp_flat_record/v1/xtcp_flat_record.proto so the _v2 MV can use the +-- positional `* EXCEPT (timestamp_ns)` form. Keep the two in sync. +CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v2 +( + -- ---- metadata: record format provenance (1-2) -------------------------- + -- schema_version is the routing epoch (0 = legacy, 2 = current); daemon_version + -- is build provenance. + schema_version UInt32 CODEC(LZ4), + daemon_version LowCardinality(String), + -- https://clickhouse.com/docs/en/sql-reference/data-types/datetime64 + timestamp_ns DateTime64(9,'UTC') CODEC(DoubleDelta, LZ4), + + -- ---- metadata: host identity (20s) ------------------------------------- + -- https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality + hostname LowCardinality(String), + location LowCardinality(String), + + -- ---- metadata: network namespace identity (30s) ------------------------ + netns String CODEC(ZSTD), + netns_inode UInt64 CODEC(ZSTD), + nsid UInt32 CODEC(LZ4), + + -- ---- metadata: container identity (40s) -------------------------------- + container_id String CODEC(ZSTD), + container_runtime LowCardinality(String), + container_name LowCardinality(String), + container_image LowCardinality(String), + + -- ---- metadata: free-form labels (50s) ---------------------------------- + label LowCardinality(String), + tag LowCardinality(String), + + -- ---- metadata: record bookkeeping (60s) -------------------------------- + record_counter UInt64 CODEC(DoubleDelta, LZ4), + socket_fd UInt64 CODEC(LZ4), + netlinker_id UInt64 CODEC(LZ4), + + -- ---- metadata: host network topology, uplink slot 1 (100s) ------------- + -- Static per boot: NIC via sysfs + ethtool, LLDP neighbor via lldpd. These + -- repeat on every record for a given host, so LowCardinality dictionary- + -- compresses them to ~nothing. + uplink1_ifname LowCardinality(String), + uplink1_nic_driver LowCardinality(String), + uplink1_nic_model LowCardinality(String), + uplink1_nic_pci_vendor UInt32 CODEC(LZ4), + uplink1_nic_pci_device UInt32 CODEC(LZ4), + uplink1_nic_bus_info LowCardinality(String), + uplink1_nic_speed_mbps UInt32 CODEC(LZ4), + uplink1_nic_fw_version LowCardinality(String), + uplink1_lldp_chassis_name LowCardinality(String), + uplink1_lldp_chassis_id LowCardinality(String), + uplink1_lldp_mgmt_ip LowCardinality(String), + uplink1_lldp_port_id LowCardinality(String), + uplink1_lldp_port_descr LowCardinality(String), + + -- ---- metadata: host network topology, uplink slot 2 (200s) ------------- + uplink2_ifname LowCardinality(String), + uplink2_nic_driver LowCardinality(String), + uplink2_nic_model LowCardinality(String), + uplink2_nic_pci_vendor UInt32 CODEC(LZ4), + uplink2_nic_pci_device UInt32 CODEC(LZ4), + uplink2_nic_bus_info LowCardinality(String), + uplink2_nic_speed_mbps UInt32 CODEC(LZ4), + uplink2_nic_fw_version LowCardinality(String), + uplink2_lldp_chassis_name LowCardinality(String), + uplink2_lldp_chassis_id LowCardinality(String), + uplink2_lldp_mgmt_ip LowCardinality(String), + uplink2_lldp_port_id LowCardinality(String), + uplink2_lldp_port_descr LowCardinality(String), + + -- ---- enrichment: daemon-computed fields (300s) -------------------------- + -- NOT read from the kernel inet_diag message; computed during enrichment + -- (rtnetlink address/route/link discovery, ipfeed ASN feeds). Empty/zero + -- when the relevant enricher is disabled or had no answer. + -- 300 socket-side (bound interface, from idiag_if) + -- 310-322 destination-side (locality/egress, ASN) + enrich_socket_interface_name LowCardinality(String), + enrich_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'local_subnet' = 2, + 'remote' = 3 + ), + enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4), + enrich_socket_dest_egress_ifname LowCardinality(String), + enrich_socket_dest_asn UInt64 CODEC(LZ4), + enrich_socket_dest_next_hop_asn UInt64 CODEC(LZ4), + enrich_socket_dest_network_owner LowCardinality(String), + + -- ---- payload: struct inet_diag_msg (1000s) ------------------------------ + inet_diag_msg_family UInt32 CODEC(LZ4), + inet_diag_msg_state UInt32 CODEC(LZ4), + inet_diag_msg_timer UInt32 CODEC(LZ4), + inet_diag_msg_retrans UInt32 CODEC(LZ4), + inet_diag_msg_socket_source_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_destination_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_source String CODEC(ZSTD), + inet_diag_msg_socket_destination String CODEC(ZSTD), + inet_diag_msg_socket_interface UInt32 CODEC(LZ4), + inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), + inet_diag_msg_expires UInt32 CODEC(LZ4), + inet_diag_msg_rqueue UInt32 CODEC(LZ4), + inet_diag_msg_wqueue UInt32 CODEC(LZ4), + inet_diag_msg_uid UInt32 CODEC(LZ4), + inet_diag_msg_inode UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_MEMINFO (1), struct inet_diag_meminfo (1100s) --- + -- Deprecated by the kernel in favour of SK_MEMINFO; kept for old kernels. + mem_info_rmem UInt32 CODEC(LZ4), + mem_info_wmem UInt32 CODEC(LZ4), + mem_info_fmem UInt32 CODEC(LZ4), + mem_info_tmem UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_INFO (2), struct tcp_info (1200s) ---------------- + -- Column names mirror the kernel member spelling (tcpi_rttvar -> tcp_info_rttvar). + tcp_info_state UInt32 CODEC(LZ4), + tcp_info_ca_state UInt32 CODEC(LZ4), + tcp_info_retransmits UInt32 CODEC(LZ4), + tcp_info_probes UInt32 CODEC(LZ4), + tcp_info_backoff UInt32 CODEC(LZ4), + tcp_info_options UInt32 CODEC(LZ4), + tcp_info_snd_wscale UInt32 CODEC(LZ4), + tcp_info_rcv_wscale UInt32 CODEC(LZ4), + tcp_info_delivery_rate_app_limited UInt32 CODEC(LZ4), + tcp_info_fastopen_client_fail UInt32 CODEC(LZ4), + tcp_info_rto UInt32 CODEC(LZ4), + tcp_info_ato UInt32 CODEC(LZ4), + tcp_info_snd_mss UInt32 CODEC(LZ4), + tcp_info_rcv_mss UInt32 CODEC(LZ4), + tcp_info_unacked UInt32 CODEC(LZ4), + tcp_info_sacked UInt32 CODEC(LZ4), + tcp_info_lost UInt32 CODEC(LZ4), + tcp_info_retrans UInt32 CODEC(LZ4), + tcp_info_fackets UInt32 CODEC(LZ4), + tcp_info_last_data_sent UInt32 CODEC(LZ4), + tcp_info_last_ack_sent UInt32 CODEC(LZ4), + tcp_info_last_data_recv UInt32 CODEC(LZ4), + tcp_info_last_ack_recv UInt32 CODEC(LZ4), + tcp_info_pmtu UInt32 CODEC(LZ4), + tcp_info_rcv_ssthresh UInt32 CODEC(LZ4), + tcp_info_rtt UInt32 CODEC(LZ4), + tcp_info_rttvar UInt32 CODEC(LZ4), + tcp_info_snd_ssthresh UInt32 CODEC(LZ4), + tcp_info_snd_cwnd UInt32 CODEC(LZ4), + tcp_info_advmss UInt32 CODEC(LZ4), + tcp_info_reordering UInt32 CODEC(LZ4), + tcp_info_rcv_rtt UInt32 CODEC(LZ4), + tcp_info_rcv_space UInt32 CODEC(LZ4), + tcp_info_total_retrans UInt32 CODEC(LZ4), + tcp_info_pacing_rate UInt64 CODEC(LZ4), + tcp_info_max_pacing_rate UInt64 CODEC(LZ4), + tcp_info_bytes_acked UInt64 CODEC(LZ4), + tcp_info_bytes_received UInt64 CODEC(LZ4), + tcp_info_segs_out UInt32 CODEC(LZ4), + tcp_info_segs_in UInt32 CODEC(LZ4), + tcp_info_notsent_bytes UInt32 CODEC(LZ4), + tcp_info_min_rtt UInt32 CODEC(LZ4), + tcp_info_data_segs_in UInt32 CODEC(LZ4), + tcp_info_data_segs_out UInt32 CODEC(LZ4), + tcp_info_delivery_rate UInt64 CODEC(LZ4), + tcp_info_busy_time UInt64 CODEC(LZ4), + tcp_info_rwnd_limited UInt64 CODEC(LZ4), + tcp_info_sndbuf_limited UInt64 CODEC(LZ4), + tcp_info_delivered UInt32 CODEC(LZ4), + tcp_info_delivered_ce UInt32 CODEC(LZ4), + tcp_info_bytes_sent UInt64 CODEC(LZ4), + tcp_info_bytes_retrans UInt64 CODEC(LZ4), + tcp_info_dsack_dups UInt32 CODEC(LZ4), + tcp_info_reord_seen UInt32 CODEC(LZ4), + tcp_info_rcv_ooopack UInt32 CODEC(LZ4), + tcp_info_snd_wnd UInt32 CODEC(LZ4), + tcp_info_rcv_wnd UInt32 CODEC(LZ4), + tcp_info_rehash UInt32 CODEC(LZ4), + tcp_info_total_rto UInt32 CODEC(LZ4), + tcp_info_total_rto_recoveries UInt32 CODEC(LZ4), + tcp_info_total_rto_time UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CONG (4) (1300s) --------------------------------- + -- inet_diag_cong is the kernel ca_ops->name string; inet_diag_cong_enum is + -- derived by xtcp from it (proto enum CongestionAlgorithm). + inet_diag_cong LowCardinality(String), + inet_diag_cong_enum Enum('' = 0, + 'cubic' = 1, + 'dctcp' = 2, + 'vegas' = 3, + 'prague' = 4, + 'bbr1' = 5, + 'bbr2' = 6, + 'bbr3' = 7 + ), + + -- ---- payload: INET_DIAG_TOS (5) / INET_DIAG_TCLASS (6) (1400s) ---------- + inet_diag_tos UInt32 CODEC(LZ4), + inet_diag_tclass UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SKMEMINFO (7), SK_MEMINFO_* (1500s) ------------- + sk_mem_info_rmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_rcvbuf UInt32 CODEC(LZ4), + sk_mem_info_wmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_sndbuf UInt32 CODEC(LZ4), + sk_mem_info_fwd_alloc UInt32 CODEC(LZ4), + sk_mem_info_wmem_queued UInt32 CODEC(LZ4), + sk_mem_info_optmem UInt32 CODEC(LZ4), + sk_mem_info_backlog UInt32 CODEC(LZ4), + sk_mem_info_drops UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SHUTDOWN (8) (1600s) ----------------------------- + inet_diag_shutdown UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_VEGASINFO (3), struct tcpvegas_info (1700s) ------ + vegas_info_enabled UInt32 CODEC(LZ4), + vegas_info_rttcnt UInt32 CODEC(LZ4), + vegas_info_rtt UInt32 CODEC(LZ4), + vegas_info_minrtt UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_DCTCPINFO (9), struct tcp_dctcp_info (1800s) ----- + dctcp_info_enabled UInt32 CODEC(LZ4), + dctcp_info_ce_state UInt32 CODEC(LZ4), + dctcp_info_alpha UInt32 CODEC(LZ4), + dctcp_info_ab_ecn UInt32 CODEC(LZ4), + dctcp_info_ab_tot UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_BBRINFO (16), struct tcp_bbr_info (1900s) -------- + bbr_info_bw_lo UInt32 CODEC(LZ4), + bbr_info_bw_hi UInt32 CODEC(LZ4), + bbr_info_min_rtt UInt32 CODEC(LZ4), + bbr_info_pacing_gain UInt32 CODEC(LZ4), + bbr_info_cwnd_gain UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CLASS_ID (17) / SOCKOPT (22) / CGROUP_ID (21) (2000s) + inet_diag_class_id UInt32 CODEC(LZ4), + inet_diag_sockopt UInt32 CODEC(LZ4), + inet_diag_cgroup_id UInt64 CODEC(LZ4), +) + ENGINE = MergeTree + -- ENGINE = ReplicatedMergeTree + -- Note that for xtcp repo, the docker is MergeTree, while k8s is ReplicatedMergeTree + ORDER BY (timestamp_ns, hostname, record_counter, netlinker_id, socket_fd) + TTL toDateTime(timestamp_ns) + INTERVAL 1 MONTH DELETE; + -- Cross-version query surface. Read-only Merge over every ^xtcp_flat_records_v[0-9]+$ --- table (excludes _kafka, _errors, and the _mv views). Backward-compatible: queries --- against xtcp_flat_records keep working and now span all versions. +-- table (excludes _kafka, _errors, and the _mv views). Declared AS the newest +-- epoch so every current column name resolves; older tables contribute defaults +-- for columns they lack (their data lives under the pre-rename names, queryable +-- directly on xtcp_flat_records_v0 / _v1). CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records - AS xtcp.xtcp_flat_records_v0 + AS xtcp.xtcp_flat_records_v2 ENGINE = Merge('xtcp', '^xtcp_flat_records_v[0-9]+$'); -- https://clickhouse.com/docs/integrations/kafka/kafka-table-engine#adding-kafka-metadata @@ -294,4 +560,4 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records -- ADD COLUMN partition UInt64, -- ADD COLUMN error String; --- end \ No newline at end of file +-- end diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql index ef5d9c5..726c36b 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_kafka.sql @@ -9,6 +9,19 @@ -- Not using Nullable, because it uses more space and apparently "almost always negatively affects performance" -- https://clickhouse.com/docs/en/sql-reference/data-types/nullable +-- Column set = epoch-2 record format (schema_version = 2), in proto field-number +-- order. ClickHouse's Protobuf/ProtobufList input maps table column NAME -> +-- schema field -> wire tag, using format_schemas/xtcp_flat_record.proto (a +-- generated copy of proto/xtcp_flat_record/v1/xtcp_flat_record.proto). So: +-- * epoch-1 daemons still in the fleet: a field that only changed NAME keeps +-- its tag, so its bytes decode into the v2-named column here and the v0/v1 +-- MVs alias it back onto the old column name. Nothing lost. +-- * epoch-1 fields that changed NUMBER (enrich_socket_dest_egress_ifindex/ +-- ifname 301/302 -> 311/312, c_group 2103 -> inet_diag_cgroup_id 2003) are +-- unknown tags to this schema and are dropped for epoch-1 rows. Those three +-- columns read as 0/'' in _v1 until the daemon fleet is on epoch 2. +-- * epoch-0 daemons never sent any of the affected fields. + -- To debug clickhouse -- make build_clickhouse_and_deploy -- docker logs xtcp-clickhouse-1 --follow @@ -20,23 +33,17 @@ DROP TABLE IF EXISTS xtcp.xtcp_flat_records_kafka; CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka ( - -- Raw int64 epoch nanoseconds straight off the protobuf (the daemon now - -- stamps true UnixNano()). The MV converts this to DateTime64(9) via - -- fromUnixTimestamp64Nano when landing rows in xtcp.xtcp_flat_records; - -- ingesting a numeric value directly into DateTime64 would be read as - -- SECONDS, not nanoseconds. - timestamp_ns Int64 CODEC(DoubleDelta, LZ4), - -- sec DateTime64(3,'UTC') CODEC(DoubleDelta, LZ4), - -- nsec Int64, - -- ---- metadata: record format provenance (1-2) -------------------------- - -- schema_version is the record format epoch (0 = pre-versioning/legacy). The - -- versioned MVs route rows by it. daemon_version is build provenance. Both - -- map by field NAME; placed right after timestamp_ns so the positional - -- MV SELECT (timestamp_ns, * EXCEPT(timestamp_ns)) lands them consistently in - -- every destination table. + -- schema_version is the routing epoch (0 = legacy, 2 = current); daemon_version + -- is build provenance. schema_version UInt32 CODEC(LZ4), daemon_version LowCardinality(String), + -- Raw int64 epoch nanoseconds straight off the protobuf (the daemon + -- stamps true UnixNano()). The MVs convert this to DateTime64(9) via + -- fromUnixTimestamp64Nano when landing rows in the _vN tables; ingesting a + -- numeric value directly into DateTime64 would be read as SECONDS, not + -- nanoseconds. + timestamp_ns Int64 CODEC(DoubleDelta, LZ4), -- ---- metadata: host identity (20s) ------------------------------------- -- https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality @@ -96,51 +103,60 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka uplink2_lldp_port_id LowCardinality(String), uplink2_lldp_port_descr LowCardinality(String), + -- ---- enrichment: daemon-computed fields (300s) -------------------------- + -- NOT read from the kernel inet_diag message; computed during enrichment + -- (rtnetlink address/route/link discovery, ipfeed ASN feeds). Empty/zero + -- when the relevant enricher is disabled or had no answer. + -- 300 socket-side (bound interface, from idiag_if) + -- 310-322 destination-side (locality/egress, ASN) + enrich_socket_interface_name LowCardinality(String), + enrich_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'local_subnet' = 2, + 'remote' = 3 + ), + enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4), + enrich_socket_dest_egress_ifname LowCardinality(String), + enrich_socket_dest_asn UInt64 CODEC(LZ4), + enrich_socket_dest_next_hop_asn UInt64 CODEC(LZ4), + enrich_socket_dest_network_owner LowCardinality(String), + + -- ---- payload: struct inet_diag_msg (1000s) ------------------------------ inet_diag_msg_family UInt32 CODEC(LZ4), inet_diag_msg_state UInt32 CODEC(LZ4), - -- inet_diag_msg_family LowCardinality(UInt32), - -- inet_diag_msg_state LowCardinality(UInt32), inet_diag_msg_timer UInt32 CODEC(LZ4), inet_diag_msg_retrans UInt32 CODEC(LZ4), - inet_diag_msg_socket_source_port UInt32 CODEC(LZ4), inet_diag_msg_socket_destination_port UInt32 CODEC(LZ4), inet_diag_msg_socket_source String CODEC(ZSTD), inet_diag_msg_socket_destination String CODEC(ZSTD), inet_diag_msg_socket_interface UInt32 CODEC(LZ4), inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), - inet_diag_msg_socket_dest_asn UInt64 CODEC(LZ4), - inet_diag_msg_socket_next_hop_asn UInt64 CODEC(LZ4), - inet_diag_msg_socket_dest_network_owner LowCardinality(String), - inet_diag_msg_socket_dest_locality Enum('unspecified' = 0, - 'self' = 1, - 'connected_subnet' = 2, - 'remote' = 3 - ), - inet_diag_msg_expires UInt32 CODEC(LZ4), inet_diag_msg_rqueue UInt32 CODEC(LZ4), inet_diag_msg_wqueue UInt32 CODEC(LZ4), inet_diag_msg_uid UInt32 CODEC(LZ4), inet_diag_msg_inode UInt32 CODEC(LZ4), + -- ---- payload: INET_DIAG_MEMINFO (1), struct inet_diag_meminfo (1100s) --- + -- Deprecated by the kernel in favour of SK_MEMINFO; kept for old kernels. mem_info_rmem UInt32 CODEC(LZ4), mem_info_wmem UInt32 CODEC(LZ4), mem_info_fmem UInt32 CODEC(LZ4), mem_info_tmem UInt32 CODEC(LZ4), + -- ---- payload: INET_DIAG_INFO (2), struct tcp_info (1200s) ---------------- + -- Column names mirror the kernel member spelling (tcpi_rttvar -> tcp_info_rttvar). tcp_info_state UInt32 CODEC(LZ4), tcp_info_ca_state UInt32 CODEC(LZ4), - -- tcp_info_state LowCardinality(UInt32), - -- tcp_info_ca_state LowCardinality(UInt32), tcp_info_retransmits UInt32 CODEC(LZ4), tcp_info_probes UInt32 CODEC(LZ4), tcp_info_backoff UInt32 CODEC(LZ4), tcp_info_options UInt32 CODEC(LZ4), - tcp_info_send_scale UInt32 CODEC(LZ4), - tcp_info_rcv_scale UInt32 CODEC(LZ4), + tcp_info_snd_wscale UInt32 CODEC(LZ4), + tcp_info_rcv_wscale UInt32 CODEC(LZ4), tcp_info_delivery_rate_app_limited UInt32 CODEC(LZ4), - tcp_info_fast_open_client_failed UInt32 CODEC(LZ4), + tcp_info_fastopen_client_fail UInt32 CODEC(LZ4), tcp_info_rto UInt32 CODEC(LZ4), tcp_info_ato UInt32 CODEC(LZ4), tcp_info_snd_mss UInt32 CODEC(LZ4), @@ -155,13 +171,12 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka tcp_info_last_data_recv UInt32 CODEC(LZ4), tcp_info_last_ack_recv UInt32 CODEC(LZ4), tcp_info_pmtu UInt32 CODEC(LZ4), - -- tcp_info_pmtu LowCardinality(UInt32), tcp_info_rcv_ssthresh UInt32 CODEC(LZ4), tcp_info_rtt UInt32 CODEC(LZ4), - tcp_info_rtt_var UInt32 CODEC(LZ4), + tcp_info_rttvar UInt32 CODEC(LZ4), tcp_info_snd_ssthresh UInt32 CODEC(LZ4), tcp_info_snd_cwnd UInt32 CODEC(LZ4), - tcp_info_adv_mss UInt32 CODEC(LZ4), + tcp_info_advmss UInt32 CODEC(LZ4), tcp_info_reordering UInt32 CODEC(LZ4), tcp_info_rcv_rtt UInt32 CODEC(LZ4), tcp_info_rcv_space UInt32 CODEC(LZ4), @@ -172,7 +187,7 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka tcp_info_bytes_received UInt64 CODEC(LZ4), tcp_info_segs_out UInt32 CODEC(LZ4), tcp_info_segs_in UInt32 CODEC(LZ4), - tcp_info_not_sent_bytes UInt32 CODEC(LZ4), + tcp_info_notsent_bytes UInt32 CODEC(LZ4), tcp_info_min_rtt UInt32 CODEC(LZ4), tcp_info_data_segs_in UInt32 CODEC(LZ4), tcp_info_data_segs_out UInt32 CODEC(LZ4), @@ -194,9 +209,11 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka tcp_info_total_rto_recoveries UInt32 CODEC(LZ4), tcp_info_total_rto_time UInt32 CODEC(LZ4), - congestion_algorithm_string LowCardinality(String), - -- congestion_algorithm_enum LowCardinality(String), - congestion_algorithm_enum Enum('' = 0, + -- ---- payload: INET_DIAG_CONG (4) (1300s) --------------------------------- + -- inet_diag_cong is the kernel ca_ops->name string; inet_diag_cong_enum is + -- derived by xtcp from it (proto enum CongestionAlgorithm). + inet_diag_cong LowCardinality(String), + inet_diag_cong_enum Enum('' = 0, 'cubic' = 1, 'dctcp' = 2, 'vegas' = 3, @@ -205,58 +222,49 @@ CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka 'bbr2' = 6, 'bbr3' = 7 ), - -- enum CongestionAlgorithm { - -- CONGESTION_ALGORITHM_UNSPECIFIED = 0; - -- CONGESTION_ALGORITHM_CUBIC = 1; - -- CONGESTION_ALGORITHM_DCTCP = 2; - -- CONGESTION_ALGORITHM_VEGAS = 3; - -- CONGESTION_ALGORITHM_PRAGUE = 4; - -- CONGESTION_ALGORITHM_BBR1 = 5; - -- CONGESTION_ALGORITHM_BBR2 = 6; - -- CONGESTION_ALGORITHM_BBR3 = 7; - -- }; - - type_of_service UInt32 CODEC(LZ4), - traffic_class UInt32 CODEC(LZ4), - -- type_of_service LowCardinality(UInt32), - -- traffic_class LowCardinality(UInt32), + -- ---- payload: INET_DIAG_TOS (5) / INET_DIAG_TCLASS (6) (1400s) ---------- + inet_diag_tos UInt32 CODEC(LZ4), + inet_diag_tclass UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SKMEMINFO (7), SK_MEMINFO_* (1500s) ------------- sk_mem_info_rmem_alloc UInt32 CODEC(LZ4), - sk_mem_info_rcv_buf UInt32 CODEC(LZ4), + sk_mem_info_rcvbuf UInt32 CODEC(LZ4), sk_mem_info_wmem_alloc UInt32 CODEC(LZ4), - sk_mem_info_snd_buf UInt32 CODEC(LZ4), + sk_mem_info_sndbuf UInt32 CODEC(LZ4), sk_mem_info_fwd_alloc UInt32 CODEC(LZ4), sk_mem_info_wmem_queued UInt32 CODEC(LZ4), sk_mem_info_optmem UInt32 CODEC(LZ4), sk_mem_info_backlog UInt32 CODEC(LZ4), sk_mem_info_drops UInt32 CODEC(LZ4), - shutdown_state UInt32 CODEC(LZ4), - -- shutdown_state LowCardinality(UInt32), + -- ---- payload: INET_DIAG_SHUTDOWN (8) (1600s) ----------------------------- + inet_diag_shutdown UInt32 CODEC(LZ4), + -- ---- payload: INET_DIAG_VEGASINFO (3), struct tcpvegas_info (1700s) ------ vegas_info_enabled UInt32 CODEC(LZ4), - -- vegas_info_enabled LowCardinality(UInt32), - vegas_info_rtt_cnt UInt32 CODEC(LZ4), + vegas_info_rttcnt UInt32 CODEC(LZ4), vegas_info_rtt UInt32 CODEC(LZ4), - vegas_info_min_rtt UInt32 CODEC(LZ4), + vegas_info_minrtt UInt32 CODEC(LZ4), + -- ---- payload: INET_DIAG_DCTCPINFO (9), struct tcp_dctcp_info (1800s) ----- dctcp_info_enabled UInt32 CODEC(LZ4), - -- dctcp_info_enabled LowCardinality(UInt32), dctcp_info_ce_state UInt32 CODEC(LZ4), dctcp_info_alpha UInt32 CODEC(LZ4), dctcp_info_ab_ecn UInt32 CODEC(LZ4), dctcp_info_ab_tot UInt32 CODEC(LZ4), + -- ---- payload: INET_DIAG_BBRINFO (16), struct tcp_bbr_info (1900s) -------- bbr_info_bw_lo UInt32 CODEC(LZ4), bbr_info_bw_hi UInt32 CODEC(LZ4), bbr_info_min_rtt UInt32 CODEC(LZ4), bbr_info_pacing_gain UInt32 CODEC(LZ4), bbr_info_cwnd_gain UInt32 CODEC(LZ4), - class_id UInt32 CODEC(LZ4), -- LowCardinality? - sock_opt UInt32 CODEC(LZ4), -- LowCardinality? - c_group UInt64 CODEC(LZ4), - + -- ---- payload: INET_DIAG_CLASS_ID (17) / SOCKOPT (22) / CGROUP_ID (21) (2000s) + inet_diag_class_id UInt32 CODEC(LZ4), + inet_diag_sockopt UInt32 CODEC(LZ4), + inet_diag_cgroup_id UInt64 CODEC(LZ4), ) ENGINE = Kafka SETTINGS @@ -314,7 +322,7 @@ SETTINGS -- https://github.com/ClickHouse/ClickHouse/blob/master/tests/integration/test_storage_kafka/test_batch_fast.py#L226 --- clickhouse-client --query "SELECT * FROM xtcp.xtcp_flat_records SETTINGS format_schema = '/var/lib/clickhouse/format_schemas/xtcp_flat_record_repeated.proto:XtcpFlatRecord' FORMAT ProtobufList" > my_export.bin +-- clickhouse-client --query "SELECT * FROM xtcp.xtcp_flat_records_v2 SETTINGS format_schema = '/var/lib/clickhouse/format_schemas/xtcp_flat_record.proto:XtcpFlatRecord' FORMAT ProtobufList" > my_export.bin -- client can use absolute path, but server cannot! -- https://github.com/ClickHouse/ClickHouse/issues/4745 diff --git a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_mv.sql b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_mv.sql index e20d80a..7d5b8d1 100644 --- a/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_mv.sql +++ b/build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records_mv.sql @@ -5,55 +5,379 @@ -- Kafka Topic --> Kakfa Table Engine --> Materialized View -> MergeTree Table -- https://clickhouse.com/docs/en/integrations/kafka/kafka-table-engine#6-create-the-materialized-view --- Per-version fan-out: one Kafka engine table feeds two MVs, split by the --- record's schema_version, into per-version MergeTree tables. ClickHouse supports --- multiple MVs reading one Kafka engine table, so this stays on the single "xtcp" --- topic. The old single MV (xtcp_flat_records_mv) is dropped in favour of these. +-- Per-version fan-out: one Kafka engine table feeds one MV per record epoch, +-- split by the record's schema_version, into per-version MergeTree tables. +-- ClickHouse supports multiple MVs reading one Kafka engine table, so this stays +-- on the single "xtcp" topic. +-- +-- A `CREATE MATERIALIZED VIEW ... TO table` inserts the SELECT's result columns +-- into the target table by NAME (INSERT semantics), not by position. +-- * _v2_mv: the Kafka table and _v2 share the epoch-2 column names, so the +-- short `* EXCEPT (timestamp_ns)` form works. +-- * _v0_mv / _v1_mv: the Kafka table carries epoch-2 names while _v0/_v1 keep +-- the epoch-0/1 names, so every renamed column is aliased explicitly +-- (new_name AS old_name). Unrenamed columns are listed too, so the SELECT +-- is a complete, order-independent mapping. Keep this list in step with the +-- rename table in docs/record-versioning.md. -- -- The Kafka-engine table carries timestamp_ns as raw Int64 epoch nanoseconds --- (protobuf int64). Convert it to DateTime64(9,'UTC') here with --- fromUnixTimestamp64Nano before landing in the MergeTree table, whose --- timestamp_ns column stays DateTime64(9). The converted column is emitted first --- and `* EXCEPT (timestamp_ns)` supplies the rest in the original order, so the --- positional SELECT->target-table mapping is preserved (timestamp_ns is column 1 --- in every table). +-- (protobuf int64). fromUnixTimestamp64Nano converts it to DateTime64(9,'UTC') +-- for the MergeTree tables. The two Enum columns are passed as their numeric +-- value (toUInt8) so the insert does not depend on the target table's enum +-- labels ('connected_subnet' on pre-v2 deployments, 'local_subnet' now). DROP VIEW IF EXISTS xtcp.xtcp_flat_records_mv; DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v0_mv; DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v1_mv; +DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v2_mv; -- Legacy bucket: pre-versioning daemons never set schema_version, so it decodes to --- proto3 zero. Those rows land in _v0. +-- proto3 zero. Those rows land in _v0. Epoch 0 never sent enrichment fields, so +-- the aliased enrichment columns are always default here. CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v0_mv TO xtcp.xtcp_flat_records_v0 AS SELECT + schema_version, + daemon_version, fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, - * EXCEPT (timestamp_ns) + hostname, + location, + netns, + netns_inode, + nsid, + container_id, + container_runtime, + container_name, + container_image, + label, + tag, + record_counter, + socket_fd, + netlinker_id, + uplink1_ifname, + uplink1_nic_driver, + uplink1_nic_model, + uplink1_nic_pci_vendor, + uplink1_nic_pci_device, + uplink1_nic_bus_info, + uplink1_nic_speed_mbps, + uplink1_nic_fw_version, + uplink1_lldp_chassis_name, + uplink1_lldp_chassis_id, + uplink1_lldp_mgmt_ip, + uplink1_lldp_port_id, + uplink1_lldp_port_descr, + uplink2_ifname, + uplink2_nic_driver, + uplink2_nic_model, + uplink2_nic_pci_vendor, + uplink2_nic_pci_device, + uplink2_nic_bus_info, + uplink2_nic_speed_mbps, + uplink2_nic_fw_version, + uplink2_lldp_chassis_name, + uplink2_lldp_chassis_id, + uplink2_lldp_mgmt_ip, + uplink2_lldp_port_id, + uplink2_lldp_port_descr, + enrich_socket_interface_name, + toUInt8(enrich_socket_dest_locality) AS enrich_socket_dest_locality, + enrich_socket_dest_egress_ifindex, + enrich_socket_dest_egress_ifname, + enrich_socket_dest_asn, + enrich_socket_dest_next_hop_asn AS enrich_socket_next_hop_asn, + enrich_socket_dest_network_owner, + inet_diag_msg_family, + inet_diag_msg_state, + inet_diag_msg_timer, + inet_diag_msg_retrans, + inet_diag_msg_socket_source_port, + inet_diag_msg_socket_destination_port, + inet_diag_msg_socket_source, + inet_diag_msg_socket_destination, + inet_diag_msg_socket_interface, + inet_diag_msg_socket_cookie, + inet_diag_msg_expires, + inet_diag_msg_rqueue, + inet_diag_msg_wqueue, + inet_diag_msg_uid, + inet_diag_msg_inode, + mem_info_rmem, + mem_info_wmem, + mem_info_fmem, + mem_info_tmem, + tcp_info_state, + tcp_info_ca_state, + tcp_info_retransmits, + tcp_info_probes, + tcp_info_backoff, + tcp_info_options, + tcp_info_snd_wscale AS tcp_info_send_scale, + tcp_info_rcv_wscale AS tcp_info_rcv_scale, + tcp_info_delivery_rate_app_limited, + tcp_info_fastopen_client_fail AS tcp_info_fast_open_client_failed, + tcp_info_rto, + tcp_info_ato, + tcp_info_snd_mss, + tcp_info_rcv_mss, + tcp_info_unacked, + tcp_info_sacked, + tcp_info_lost, + tcp_info_retrans, + tcp_info_fackets, + tcp_info_last_data_sent, + tcp_info_last_ack_sent, + tcp_info_last_data_recv, + tcp_info_last_ack_recv, + tcp_info_pmtu, + tcp_info_rcv_ssthresh, + tcp_info_rtt, + tcp_info_rttvar AS tcp_info_rtt_var, + tcp_info_snd_ssthresh, + tcp_info_snd_cwnd, + tcp_info_advmss AS tcp_info_adv_mss, + tcp_info_reordering, + tcp_info_rcv_rtt, + tcp_info_rcv_space, + tcp_info_total_retrans, + tcp_info_pacing_rate, + tcp_info_max_pacing_rate, + tcp_info_bytes_acked, + tcp_info_bytes_received, + tcp_info_segs_out, + tcp_info_segs_in, + tcp_info_notsent_bytes AS tcp_info_not_sent_bytes, + tcp_info_min_rtt, + tcp_info_data_segs_in, + tcp_info_data_segs_out, + tcp_info_delivery_rate, + tcp_info_busy_time, + tcp_info_rwnd_limited, + tcp_info_sndbuf_limited, + tcp_info_delivered, + tcp_info_delivered_ce, + tcp_info_bytes_sent, + tcp_info_bytes_retrans, + tcp_info_dsack_dups, + tcp_info_reord_seen, + tcp_info_rcv_ooopack, + tcp_info_snd_wnd, + tcp_info_rcv_wnd, + tcp_info_rehash, + tcp_info_total_rto, + tcp_info_total_rto_recoveries, + tcp_info_total_rto_time, + inet_diag_cong AS congestion_algorithm_string, + toUInt8(inet_diag_cong_enum) AS congestion_algorithm_enum, + inet_diag_tos AS type_of_service, + inet_diag_tclass AS traffic_class, + sk_mem_info_rmem_alloc, + sk_mem_info_rcvbuf AS sk_mem_info_rcv_buf, + sk_mem_info_wmem_alloc, + sk_mem_info_sndbuf AS sk_mem_info_snd_buf, + sk_mem_info_fwd_alloc, + sk_mem_info_wmem_queued, + sk_mem_info_optmem, + sk_mem_info_backlog, + sk_mem_info_drops, + inet_diag_shutdown AS shutdown_state, + vegas_info_enabled, + vegas_info_rttcnt AS vegas_info_rtt_cnt, + vegas_info_rtt, + vegas_info_minrtt AS vegas_info_min_rtt, + dctcp_info_enabled, + dctcp_info_ce_state, + dctcp_info_alpha, + dctcp_info_ab_ecn, + dctcp_info_ab_tot, + bbr_info_bw_lo, + bbr_info_bw_hi, + bbr_info_min_rtt, + bbr_info_pacing_gain, + bbr_info_cwnd_gain, + inet_diag_class_id AS class_id, + inet_diag_sockopt AS sock_opt, + inet_diag_cgroup_id AS c_group FROM xtcp.xtcp_flat_records_kafka WHERE length(_error) == 0 AND schema_version = 0; --- Current format (XtcpFlatRecordSchemaVersion = 1). +-- Epoch 1 (XtcpFlatRecordSchemaVersion = 1). Same alias list as _v0_mv. Note the +-- three renumbered fields (egress_ifindex/ifname, cgroup id) cannot be recovered +-- for epoch-1 rows: the Kafka schema only knows their epoch-2 tags. CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v1_mv TO xtcp.xtcp_flat_records_v1 AS SELECT + schema_version, + daemon_version, fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, - * EXCEPT (timestamp_ns) + hostname, + location, + netns, + netns_inode, + nsid, + container_id, + container_runtime, + container_name, + container_image, + label, + tag, + record_counter, + socket_fd, + netlinker_id, + uplink1_ifname, + uplink1_nic_driver, + uplink1_nic_model, + uplink1_nic_pci_vendor, + uplink1_nic_pci_device, + uplink1_nic_bus_info, + uplink1_nic_speed_mbps, + uplink1_nic_fw_version, + uplink1_lldp_chassis_name, + uplink1_lldp_chassis_id, + uplink1_lldp_mgmt_ip, + uplink1_lldp_port_id, + uplink1_lldp_port_descr, + uplink2_ifname, + uplink2_nic_driver, + uplink2_nic_model, + uplink2_nic_pci_vendor, + uplink2_nic_pci_device, + uplink2_nic_bus_info, + uplink2_nic_speed_mbps, + uplink2_nic_fw_version, + uplink2_lldp_chassis_name, + uplink2_lldp_chassis_id, + uplink2_lldp_mgmt_ip, + uplink2_lldp_port_id, + uplink2_lldp_port_descr, + enrich_socket_interface_name, + toUInt8(enrich_socket_dest_locality) AS enrich_socket_dest_locality, + enrich_socket_dest_egress_ifindex, + enrich_socket_dest_egress_ifname, + enrich_socket_dest_asn, + enrich_socket_dest_next_hop_asn AS enrich_socket_next_hop_asn, + enrich_socket_dest_network_owner, + inet_diag_msg_family, + inet_diag_msg_state, + inet_diag_msg_timer, + inet_diag_msg_retrans, + inet_diag_msg_socket_source_port, + inet_diag_msg_socket_destination_port, + inet_diag_msg_socket_source, + inet_diag_msg_socket_destination, + inet_diag_msg_socket_interface, + inet_diag_msg_socket_cookie, + inet_diag_msg_expires, + inet_diag_msg_rqueue, + inet_diag_msg_wqueue, + inet_diag_msg_uid, + inet_diag_msg_inode, + mem_info_rmem, + mem_info_wmem, + mem_info_fmem, + mem_info_tmem, + tcp_info_state, + tcp_info_ca_state, + tcp_info_retransmits, + tcp_info_probes, + tcp_info_backoff, + tcp_info_options, + tcp_info_snd_wscale AS tcp_info_send_scale, + tcp_info_rcv_wscale AS tcp_info_rcv_scale, + tcp_info_delivery_rate_app_limited, + tcp_info_fastopen_client_fail AS tcp_info_fast_open_client_failed, + tcp_info_rto, + tcp_info_ato, + tcp_info_snd_mss, + tcp_info_rcv_mss, + tcp_info_unacked, + tcp_info_sacked, + tcp_info_lost, + tcp_info_retrans, + tcp_info_fackets, + tcp_info_last_data_sent, + tcp_info_last_ack_sent, + tcp_info_last_data_recv, + tcp_info_last_ack_recv, + tcp_info_pmtu, + tcp_info_rcv_ssthresh, + tcp_info_rtt, + tcp_info_rttvar AS tcp_info_rtt_var, + tcp_info_snd_ssthresh, + tcp_info_snd_cwnd, + tcp_info_advmss AS tcp_info_adv_mss, + tcp_info_reordering, + tcp_info_rcv_rtt, + tcp_info_rcv_space, + tcp_info_total_retrans, + tcp_info_pacing_rate, + tcp_info_max_pacing_rate, + tcp_info_bytes_acked, + tcp_info_bytes_received, + tcp_info_segs_out, + tcp_info_segs_in, + tcp_info_notsent_bytes AS tcp_info_not_sent_bytes, + tcp_info_min_rtt, + tcp_info_data_segs_in, + tcp_info_data_segs_out, + tcp_info_delivery_rate, + tcp_info_busy_time, + tcp_info_rwnd_limited, + tcp_info_sndbuf_limited, + tcp_info_delivered, + tcp_info_delivered_ce, + tcp_info_bytes_sent, + tcp_info_bytes_retrans, + tcp_info_dsack_dups, + tcp_info_reord_seen, + tcp_info_rcv_ooopack, + tcp_info_snd_wnd, + tcp_info_rcv_wnd, + tcp_info_rehash, + tcp_info_total_rto, + tcp_info_total_rto_recoveries, + tcp_info_total_rto_time, + inet_diag_cong AS congestion_algorithm_string, + toUInt8(inet_diag_cong_enum) AS congestion_algorithm_enum, + inet_diag_tos AS type_of_service, + inet_diag_tclass AS traffic_class, + sk_mem_info_rmem_alloc, + sk_mem_info_rcvbuf AS sk_mem_info_rcv_buf, + sk_mem_info_wmem_alloc, + sk_mem_info_sndbuf AS sk_mem_info_snd_buf, + sk_mem_info_fwd_alloc, + sk_mem_info_wmem_queued, + sk_mem_info_optmem, + sk_mem_info_backlog, + sk_mem_info_drops, + inet_diag_shutdown AS shutdown_state, + vegas_info_enabled, + vegas_info_rttcnt AS vegas_info_rtt_cnt, + vegas_info_rtt, + vegas_info_minrtt AS vegas_info_min_rtt, + dctcp_info_enabled, + dctcp_info_ce_state, + dctcp_info_alpha, + dctcp_info_ab_ecn, + dctcp_info_ab_tot, + bbr_info_bw_lo, + bbr_info_bw_hi, + bbr_info_min_rtt, + bbr_info_pacing_gain, + bbr_info_cwnd_gain, + inet_diag_class_id AS class_id, + inet_diag_sockopt AS sock_opt, + inet_diag_cgroup_id AS c_group FROM xtcp.xtcp_flat_records_kafka WHERE length(_error) == 0 AND schema_version = 1; --- https://github.com/ClickHouse/ClickHouse/blob/master/tests/integration/test_storage_kafka/test_batch_fast.py#L2678 - --- 756526eb1051 :) SHOW CREATE TABLE xtcp.xtcp_flat_records_mv; - --- SHOW CREATE TABLE xtcp.xtcp_flat_records_mv +-- Current format (XtcpFlatRecordSchemaVersion = 2). Column names match 1:1. +CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v2_mv TO xtcp.xtcp_flat_records_v2 + AS SELECT + fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, + * EXCEPT (timestamp_ns) + FROM xtcp.xtcp_flat_records_kafka + WHERE length(_error) == 0 AND schema_version = 2; --- Query id: 7f84109e-97e5-42c4-a12f-73248761ee90 +-- https://github.com/ClickHouse/ClickHouse/blob/master/tests/integration/test_storage_kafka/test_batch_fast.py#L2678 --- ┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ --- 1. │ CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_mv TO xtcp.xtcp_flat_records ↴│ --- │↳( ↴│ --- │↳ `timestamp_ns` DateTime64(9, 'UTC'), ↴│ --- │↳ `hostname` LowCardinality(String), ↴│ --- │↳ `netns` String, ↴│ --- │↳ `nsid` UInt32, ↴│ --- │↳ `label` LowCardinality(String), --- ... +-- SHOW CREATE TABLE xtcp.xtcp_flat_records_v2_mv; --- end \ No newline at end of file +-- end diff --git a/build/containers/clickhouse/select_statements.sql b/build/containers/clickhouse/select_statements.sql index 8c4273f..7ccd256 100644 --- a/build/containers/clickhouse/select_statements.sql +++ b/build/containers/clickhouse/select_statements.sql @@ -16,7 +16,7 @@ SELECT inet_diag_msg_socket_source_port, inet_diag_msg_socket_destination_port, tcp_info_rtt, - tcp_info_rtt_var, + tcp_info_rttvar, tcp_info_min_rtt, tcp_info_rcv_rtt, tcp_info_busy_time, diff --git a/build/containers/clickhouse/sql/migrations/v2.sql b/build/containers/clickhouse/sql/migrations/v2.sql new file mode 100644 index 0000000..1165108 --- /dev/null +++ b/build/containers/clickhouse/sql/migrations/v2.sql @@ -0,0 +1,966 @@ +-- +-- Migration: record format epoch 1 -> epoch 2 (XtcpFlatRecordSchemaVersion = 2) +-- +-- For EXISTING deployments that already run the epoch-0/1 layout from +-- build/containers/clickhouse/initdb.d/sql/. Fresh deployments do not need this: +-- initdb.d recreates everything from scratch. +-- +-- Apply with (data in _v0/_v1 is untouched; only the Kafka table, the MVs and the +-- Merge view are recreated, plus a new empty _v2 table): +-- +-- clickhouse-client --multiquery < build/containers/clickhouse/sql/migrations/v2.sql +-- +-- What changed in epoch 2 (proto/xtcp_flat_record/v1/xtcp_flat_record.proto): +-- * 18 payload columns renamed to the kernel struct member spelling, e.g. +-- tcp_info_rtt_var -> tcp_info_rttvar, type_of_service -> inet_diag_tos, +-- congestion_algorithm_string -> inet_diag_cong, c_group -> inet_diag_cgroup_id. +-- * enrich_socket_next_hop_asn -> enrich_socket_dest_next_hop_asn. +-- * Three fields changed NUMBER: enrich_socket_dest_egress_ifindex 301 -> 311, +-- enrich_socket_dest_egress_ifname 302 -> 312, c_group 2103 -> +-- inet_diag_cgroup_id 2003. +-- * Locality enum label 'connected_subnet' -> 'local_subnet' (value 2 unchanged). +-- Full table: docs/record-versioning.md. +-- +-- Mixed-fleet behaviour while epoch-1 daemons are still producing (the Kafka +-- table decodes by column NAME -> proto tag against the epoch-2 schema): +-- * renamed-only fields keep their tag, decode fine, and the _v1 MV aliases +-- them back onto the old _v1 column names -> no data loss; +-- * the three RENUMBERED fields are unknown tags for epoch-1 rows and are +-- DROPPED: _v1.enrich_socket_dest_egress_ifindex/ifname and _v1.c_group read +-- as 0/'' for rows produced after this migration until the daemon fleet is on +-- epoch 2. Roll the daemons soon after applying this. +-- +-- Cross-epoch reads: the Merge view xtcp.xtcp_flat_records is re-declared AS +-- _v2, so epoch-2 column names resolve everywhere; for epoch-0/1 rows those +-- columns read as defaults (their data is under the old names in _v0/_v1). +-- If you prefer one coherent name set across all epochs instead, run +-- ALTER TABLE xtcp.xtcp_flat_records_v1 RENAME COLUMN tcp_info_rtt_var TO tcp_info_rttvar, ... +-- for each pair in the rename table AND switch _v0_mv/_v1_mv to the +-- `* EXCEPT (timestamp_ns)` form. This file deliberately does not do that, to +-- leave the epoch-0/1 tables exactly as they were. + +-- Also copy the regenerated schema file into the server's format_schemas dir +-- before running this (the Kafka table below references it): +-- build/containers/clickhouse/format_schemas/xtcp_flat_record.proto +-- -> /var/lib/clickhouse/format_schemas/xtcp_flat_record.proto + +-- 1. Stop ingestion while the schema swaps. +DROP VIEW IF EXISTS xtcp.xtcp_flat_records_mv; +DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v0_mv; +DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v1_mv; +DROP VIEW IF EXISTS xtcp.xtcp_flat_records_v2_mv; +DROP TABLE IF EXISTS xtcp.xtcp_flat_records_kafka; + +-- 2. Bring the existing epoch-0/1 tables up to the column set the new +-- _v0_mv/_v1_mv alias lists insert into. Deployments created from main before +-- the enrichment block landed (xtcp2 <= 1.3.x) lack these seven columns; +-- ADD COLUMN IF NOT EXISTS is a no-op where they already exist. The two +-- never-populated epoch-1 columns inet_diag_msg_socket_dest_asn / +-- inet_diag_msg_socket_next_hop_asn (tags 1011/1012, now reserved) are left in +-- place; nothing writes them any more. +ALTER TABLE xtcp.xtcp_flat_records_v0 + ADD COLUMN IF NOT EXISTS enrich_socket_interface_name LowCardinality(String) AFTER uplink2_lldp_port_descr, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4) AFTER enrich_socket_interface_name, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_egress_ifname LowCardinality(String) AFTER enrich_socket_dest_egress_ifindex, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_locality Enum('unspecified' = 0, 'self' = 1, 'local_subnet' = 2, 'remote' = 3) AFTER enrich_socket_dest_egress_ifname, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_asn UInt64 CODEC(LZ4) AFTER enrich_socket_dest_locality, + ADD COLUMN IF NOT EXISTS enrich_socket_next_hop_asn UInt64 CODEC(LZ4) AFTER enrich_socket_dest_asn, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_network_owner LowCardinality(String) AFTER enrich_socket_next_hop_asn; +ALTER TABLE xtcp.xtcp_flat_records_v1 + ADD COLUMN IF NOT EXISTS enrich_socket_interface_name LowCardinality(String) AFTER uplink2_lldp_port_descr, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4) AFTER enrich_socket_interface_name, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_egress_ifname LowCardinality(String) AFTER enrich_socket_dest_egress_ifindex, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_locality Enum('unspecified' = 0, 'self' = 1, 'local_subnet' = 2, 'remote' = 3) AFTER enrich_socket_dest_egress_ifname, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_asn UInt64 CODEC(LZ4) AFTER enrich_socket_dest_locality, + ADD COLUMN IF NOT EXISTS enrich_socket_next_hop_asn UInt64 CODEC(LZ4) AFTER enrich_socket_dest_asn, + ADD COLUMN IF NOT EXISTS enrich_socket_dest_network_owner LowCardinality(String) AFTER enrich_socket_next_hop_asn; + +-- Unify the locality label where the column pre-existed as +-- 'connected_subnet' (metadata-only; the stored UInt8 values are unchanged). +ALTER TABLE xtcp.xtcp_flat_records_v0 MODIFY COLUMN enrich_socket_dest_locality + Enum('unspecified' = 0, 'self' = 1, 'local_subnet' = 2, 'remote' = 3); +ALTER TABLE xtcp.xtcp_flat_records_v1 MODIFY COLUMN enrich_socket_dest_locality + Enum('unspecified' = 0, 'self' = 1, 'local_subnet' = 2, 'remote' = 3); + +-- 3. New epoch-2 table. +CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_v2 +( + -- ---- metadata: record format provenance (1-2) -------------------------- + -- schema_version is the routing epoch (0 = legacy, 2 = current); daemon_version + -- is build provenance. + schema_version UInt32 CODEC(LZ4), + daemon_version LowCardinality(String), + -- https://clickhouse.com/docs/en/sql-reference/data-types/datetime64 + timestamp_ns DateTime64(9,'UTC') CODEC(DoubleDelta, LZ4), + + -- ---- metadata: host identity (20s) ------------------------------------- + -- https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality + hostname LowCardinality(String), + location LowCardinality(String), + + -- ---- metadata: network namespace identity (30s) ------------------------ + netns String CODEC(ZSTD), + netns_inode UInt64 CODEC(ZSTD), + nsid UInt32 CODEC(LZ4), + + -- ---- metadata: container identity (40s) -------------------------------- + container_id String CODEC(ZSTD), + container_runtime LowCardinality(String), + container_name LowCardinality(String), + container_image LowCardinality(String), + + -- ---- metadata: free-form labels (50s) ---------------------------------- + label LowCardinality(String), + tag LowCardinality(String), + + -- ---- metadata: record bookkeeping (60s) -------------------------------- + record_counter UInt64 CODEC(DoubleDelta, LZ4), + socket_fd UInt64 CODEC(LZ4), + netlinker_id UInt64 CODEC(LZ4), + + -- ---- metadata: host network topology, uplink slot 1 (100s) ------------- + -- Static per boot: NIC via sysfs + ethtool, LLDP neighbor via lldpd. These + -- repeat on every record for a given host, so LowCardinality dictionary- + -- compresses them to ~nothing. + uplink1_ifname LowCardinality(String), + uplink1_nic_driver LowCardinality(String), + uplink1_nic_model LowCardinality(String), + uplink1_nic_pci_vendor UInt32 CODEC(LZ4), + uplink1_nic_pci_device UInt32 CODEC(LZ4), + uplink1_nic_bus_info LowCardinality(String), + uplink1_nic_speed_mbps UInt32 CODEC(LZ4), + uplink1_nic_fw_version LowCardinality(String), + uplink1_lldp_chassis_name LowCardinality(String), + uplink1_lldp_chassis_id LowCardinality(String), + uplink1_lldp_mgmt_ip LowCardinality(String), + uplink1_lldp_port_id LowCardinality(String), + uplink1_lldp_port_descr LowCardinality(String), + + -- ---- metadata: host network topology, uplink slot 2 (200s) ------------- + uplink2_ifname LowCardinality(String), + uplink2_nic_driver LowCardinality(String), + uplink2_nic_model LowCardinality(String), + uplink2_nic_pci_vendor UInt32 CODEC(LZ4), + uplink2_nic_pci_device UInt32 CODEC(LZ4), + uplink2_nic_bus_info LowCardinality(String), + uplink2_nic_speed_mbps UInt32 CODEC(LZ4), + uplink2_nic_fw_version LowCardinality(String), + uplink2_lldp_chassis_name LowCardinality(String), + uplink2_lldp_chassis_id LowCardinality(String), + uplink2_lldp_mgmt_ip LowCardinality(String), + uplink2_lldp_port_id LowCardinality(String), + uplink2_lldp_port_descr LowCardinality(String), + + -- ---- enrichment: daemon-computed fields (300s) -------------------------- + -- NOT read from the kernel inet_diag message; computed during enrichment + -- (rtnetlink address/route/link discovery, ipfeed ASN feeds). Empty/zero + -- when the relevant enricher is disabled or had no answer. + -- 300 socket-side (bound interface, from idiag_if) + -- 310-322 destination-side (locality/egress, ASN) + enrich_socket_interface_name LowCardinality(String), + enrich_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'local_subnet' = 2, + 'remote' = 3 + ), + enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4), + enrich_socket_dest_egress_ifname LowCardinality(String), + enrich_socket_dest_asn UInt64 CODEC(LZ4), + enrich_socket_dest_next_hop_asn UInt64 CODEC(LZ4), + enrich_socket_dest_network_owner LowCardinality(String), + + -- ---- payload: struct inet_diag_msg (1000s) ------------------------------ + inet_diag_msg_family UInt32 CODEC(LZ4), + inet_diag_msg_state UInt32 CODEC(LZ4), + inet_diag_msg_timer UInt32 CODEC(LZ4), + inet_diag_msg_retrans UInt32 CODEC(LZ4), + inet_diag_msg_socket_source_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_destination_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_source String CODEC(ZSTD), + inet_diag_msg_socket_destination String CODEC(ZSTD), + inet_diag_msg_socket_interface UInt32 CODEC(LZ4), + inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), + inet_diag_msg_expires UInt32 CODEC(LZ4), + inet_diag_msg_rqueue UInt32 CODEC(LZ4), + inet_diag_msg_wqueue UInt32 CODEC(LZ4), + inet_diag_msg_uid UInt32 CODEC(LZ4), + inet_diag_msg_inode UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_MEMINFO (1), struct inet_diag_meminfo (1100s) --- + -- Deprecated by the kernel in favour of SK_MEMINFO; kept for old kernels. + mem_info_rmem UInt32 CODEC(LZ4), + mem_info_wmem UInt32 CODEC(LZ4), + mem_info_fmem UInt32 CODEC(LZ4), + mem_info_tmem UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_INFO (2), struct tcp_info (1200s) ---------------- + -- Column names mirror the kernel member spelling (tcpi_rttvar -> tcp_info_rttvar). + tcp_info_state UInt32 CODEC(LZ4), + tcp_info_ca_state UInt32 CODEC(LZ4), + tcp_info_retransmits UInt32 CODEC(LZ4), + tcp_info_probes UInt32 CODEC(LZ4), + tcp_info_backoff UInt32 CODEC(LZ4), + tcp_info_options UInt32 CODEC(LZ4), + tcp_info_snd_wscale UInt32 CODEC(LZ4), + tcp_info_rcv_wscale UInt32 CODEC(LZ4), + tcp_info_delivery_rate_app_limited UInt32 CODEC(LZ4), + tcp_info_fastopen_client_fail UInt32 CODEC(LZ4), + tcp_info_rto UInt32 CODEC(LZ4), + tcp_info_ato UInt32 CODEC(LZ4), + tcp_info_snd_mss UInt32 CODEC(LZ4), + tcp_info_rcv_mss UInt32 CODEC(LZ4), + tcp_info_unacked UInt32 CODEC(LZ4), + tcp_info_sacked UInt32 CODEC(LZ4), + tcp_info_lost UInt32 CODEC(LZ4), + tcp_info_retrans UInt32 CODEC(LZ4), + tcp_info_fackets UInt32 CODEC(LZ4), + tcp_info_last_data_sent UInt32 CODEC(LZ4), + tcp_info_last_ack_sent UInt32 CODEC(LZ4), + tcp_info_last_data_recv UInt32 CODEC(LZ4), + tcp_info_last_ack_recv UInt32 CODEC(LZ4), + tcp_info_pmtu UInt32 CODEC(LZ4), + tcp_info_rcv_ssthresh UInt32 CODEC(LZ4), + tcp_info_rtt UInt32 CODEC(LZ4), + tcp_info_rttvar UInt32 CODEC(LZ4), + tcp_info_snd_ssthresh UInt32 CODEC(LZ4), + tcp_info_snd_cwnd UInt32 CODEC(LZ4), + tcp_info_advmss UInt32 CODEC(LZ4), + tcp_info_reordering UInt32 CODEC(LZ4), + tcp_info_rcv_rtt UInt32 CODEC(LZ4), + tcp_info_rcv_space UInt32 CODEC(LZ4), + tcp_info_total_retrans UInt32 CODEC(LZ4), + tcp_info_pacing_rate UInt64 CODEC(LZ4), + tcp_info_max_pacing_rate UInt64 CODEC(LZ4), + tcp_info_bytes_acked UInt64 CODEC(LZ4), + tcp_info_bytes_received UInt64 CODEC(LZ4), + tcp_info_segs_out UInt32 CODEC(LZ4), + tcp_info_segs_in UInt32 CODEC(LZ4), + tcp_info_notsent_bytes UInt32 CODEC(LZ4), + tcp_info_min_rtt UInt32 CODEC(LZ4), + tcp_info_data_segs_in UInt32 CODEC(LZ4), + tcp_info_data_segs_out UInt32 CODEC(LZ4), + tcp_info_delivery_rate UInt64 CODEC(LZ4), + tcp_info_busy_time UInt64 CODEC(LZ4), + tcp_info_rwnd_limited UInt64 CODEC(LZ4), + tcp_info_sndbuf_limited UInt64 CODEC(LZ4), + tcp_info_delivered UInt32 CODEC(LZ4), + tcp_info_delivered_ce UInt32 CODEC(LZ4), + tcp_info_bytes_sent UInt64 CODEC(LZ4), + tcp_info_bytes_retrans UInt64 CODEC(LZ4), + tcp_info_dsack_dups UInt32 CODEC(LZ4), + tcp_info_reord_seen UInt32 CODEC(LZ4), + tcp_info_rcv_ooopack UInt32 CODEC(LZ4), + tcp_info_snd_wnd UInt32 CODEC(LZ4), + tcp_info_rcv_wnd UInt32 CODEC(LZ4), + tcp_info_rehash UInt32 CODEC(LZ4), + tcp_info_total_rto UInt32 CODEC(LZ4), + tcp_info_total_rto_recoveries UInt32 CODEC(LZ4), + tcp_info_total_rto_time UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CONG (4) (1300s) --------------------------------- + -- inet_diag_cong is the kernel ca_ops->name string; inet_diag_cong_enum is + -- derived by xtcp from it (proto enum CongestionAlgorithm). + inet_diag_cong LowCardinality(String), + inet_diag_cong_enum Enum('' = 0, + 'cubic' = 1, + 'dctcp' = 2, + 'vegas' = 3, + 'prague' = 4, + 'bbr1' = 5, + 'bbr2' = 6, + 'bbr3' = 7 + ), + + -- ---- payload: INET_DIAG_TOS (5) / INET_DIAG_TCLASS (6) (1400s) ---------- + inet_diag_tos UInt32 CODEC(LZ4), + inet_diag_tclass UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SKMEMINFO (7), SK_MEMINFO_* (1500s) ------------- + sk_mem_info_rmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_rcvbuf UInt32 CODEC(LZ4), + sk_mem_info_wmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_sndbuf UInt32 CODEC(LZ4), + sk_mem_info_fwd_alloc UInt32 CODEC(LZ4), + sk_mem_info_wmem_queued UInt32 CODEC(LZ4), + sk_mem_info_optmem UInt32 CODEC(LZ4), + sk_mem_info_backlog UInt32 CODEC(LZ4), + sk_mem_info_drops UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SHUTDOWN (8) (1600s) ----------------------------- + inet_diag_shutdown UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_VEGASINFO (3), struct tcpvegas_info (1700s) ------ + vegas_info_enabled UInt32 CODEC(LZ4), + vegas_info_rttcnt UInt32 CODEC(LZ4), + vegas_info_rtt UInt32 CODEC(LZ4), + vegas_info_minrtt UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_DCTCPINFO (9), struct tcp_dctcp_info (1800s) ----- + dctcp_info_enabled UInt32 CODEC(LZ4), + dctcp_info_ce_state UInt32 CODEC(LZ4), + dctcp_info_alpha UInt32 CODEC(LZ4), + dctcp_info_ab_ecn UInt32 CODEC(LZ4), + dctcp_info_ab_tot UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_BBRINFO (16), struct tcp_bbr_info (1900s) -------- + bbr_info_bw_lo UInt32 CODEC(LZ4), + bbr_info_bw_hi UInt32 CODEC(LZ4), + bbr_info_min_rtt UInt32 CODEC(LZ4), + bbr_info_pacing_gain UInt32 CODEC(LZ4), + bbr_info_cwnd_gain UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CLASS_ID (17) / SOCKOPT (22) / CGROUP_ID (21) (2000s) + inet_diag_class_id UInt32 CODEC(LZ4), + inet_diag_sockopt UInt32 CODEC(LZ4), + inet_diag_cgroup_id UInt64 CODEC(LZ4), +) + ENGINE = MergeTree + -- ENGINE = ReplicatedMergeTree + -- Note that for xtcp repo, the docker is MergeTree, while k8s is ReplicatedMergeTree + ORDER BY (timestamp_ns, hostname, record_counter, netlinker_id, socket_fd) + TTL toDateTime(timestamp_ns) + INTERVAL 1 MONTH DELETE; + +-- 4. Kafka table with the epoch-2 column set. +CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records_kafka +( + -- ---- metadata: record format provenance (1-2) -------------------------- + -- schema_version is the routing epoch (0 = legacy, 2 = current); daemon_version + -- is build provenance. + schema_version UInt32 CODEC(LZ4), + daemon_version LowCardinality(String), + -- Raw int64 epoch nanoseconds straight off the protobuf (the daemon + -- stamps true UnixNano()). The MVs convert this to DateTime64(9) via + -- fromUnixTimestamp64Nano when landing rows in the _vN tables; ingesting a + -- numeric value directly into DateTime64 would be read as SECONDS, not + -- nanoseconds. + timestamp_ns Int64 CODEC(DoubleDelta, LZ4), + + -- ---- metadata: host identity (20s) ------------------------------------- + -- https://clickhouse.com/docs/en/sql-reference/data-types/lowcardinality + hostname LowCardinality(String), + location LowCardinality(String), + + -- ---- metadata: network namespace identity (30s) ------------------------ + netns String CODEC(ZSTD), + netns_inode UInt64 CODEC(ZSTD), + nsid UInt32 CODEC(LZ4), + + -- ---- metadata: container identity (40s) -------------------------------- + container_id String CODEC(ZSTD), + container_runtime LowCardinality(String), + container_name LowCardinality(String), + container_image LowCardinality(String), + + -- ---- metadata: free-form labels (50s) ---------------------------------- + label LowCardinality(String), + tag LowCardinality(String), + + -- ---- metadata: record bookkeeping (60s) -------------------------------- + record_counter UInt64 CODEC(DoubleDelta, LZ4), + socket_fd UInt64 CODEC(LZ4), + netlinker_id UInt64 CODEC(LZ4), + + -- ---- metadata: host network topology, uplink slot 1 (100s) ------------- + -- Static per boot: NIC via sysfs + ethtool, LLDP neighbor via lldpd. These + -- repeat on every record for a given host, so LowCardinality dictionary- + -- compresses them to ~nothing. + uplink1_ifname LowCardinality(String), + uplink1_nic_driver LowCardinality(String), + uplink1_nic_model LowCardinality(String), + uplink1_nic_pci_vendor UInt32 CODEC(LZ4), + uplink1_nic_pci_device UInt32 CODEC(LZ4), + uplink1_nic_bus_info LowCardinality(String), + uplink1_nic_speed_mbps UInt32 CODEC(LZ4), + uplink1_nic_fw_version LowCardinality(String), + uplink1_lldp_chassis_name LowCardinality(String), + uplink1_lldp_chassis_id LowCardinality(String), + uplink1_lldp_mgmt_ip LowCardinality(String), + uplink1_lldp_port_id LowCardinality(String), + uplink1_lldp_port_descr LowCardinality(String), + + -- ---- metadata: host network topology, uplink slot 2 (200s) ------------- + uplink2_ifname LowCardinality(String), + uplink2_nic_driver LowCardinality(String), + uplink2_nic_model LowCardinality(String), + uplink2_nic_pci_vendor UInt32 CODEC(LZ4), + uplink2_nic_pci_device UInt32 CODEC(LZ4), + uplink2_nic_bus_info LowCardinality(String), + uplink2_nic_speed_mbps UInt32 CODEC(LZ4), + uplink2_nic_fw_version LowCardinality(String), + uplink2_lldp_chassis_name LowCardinality(String), + uplink2_lldp_chassis_id LowCardinality(String), + uplink2_lldp_mgmt_ip LowCardinality(String), + uplink2_lldp_port_id LowCardinality(String), + uplink2_lldp_port_descr LowCardinality(String), + + -- ---- enrichment: daemon-computed fields (300s) -------------------------- + -- NOT read from the kernel inet_diag message; computed during enrichment + -- (rtnetlink address/route/link discovery, ipfeed ASN feeds). Empty/zero + -- when the relevant enricher is disabled or had no answer. + -- 300 socket-side (bound interface, from idiag_if) + -- 310-322 destination-side (locality/egress, ASN) + enrich_socket_interface_name LowCardinality(String), + enrich_socket_dest_locality Enum('unspecified' = 0, + 'self' = 1, + 'local_subnet' = 2, + 'remote' = 3 + ), + enrich_socket_dest_egress_ifindex UInt32 CODEC(LZ4), + enrich_socket_dest_egress_ifname LowCardinality(String), + enrich_socket_dest_asn UInt64 CODEC(LZ4), + enrich_socket_dest_next_hop_asn UInt64 CODEC(LZ4), + enrich_socket_dest_network_owner LowCardinality(String), + + -- ---- payload: struct inet_diag_msg (1000s) ------------------------------ + inet_diag_msg_family UInt32 CODEC(LZ4), + inet_diag_msg_state UInt32 CODEC(LZ4), + inet_diag_msg_timer UInt32 CODEC(LZ4), + inet_diag_msg_retrans UInt32 CODEC(LZ4), + inet_diag_msg_socket_source_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_destination_port UInt32 CODEC(LZ4), + inet_diag_msg_socket_source String CODEC(ZSTD), + inet_diag_msg_socket_destination String CODEC(ZSTD), + inet_diag_msg_socket_interface UInt32 CODEC(LZ4), + inet_diag_msg_socket_cookie UInt64 CODEC(LZ4), + inet_diag_msg_expires UInt32 CODEC(LZ4), + inet_diag_msg_rqueue UInt32 CODEC(LZ4), + inet_diag_msg_wqueue UInt32 CODEC(LZ4), + inet_diag_msg_uid UInt32 CODEC(LZ4), + inet_diag_msg_inode UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_MEMINFO (1), struct inet_diag_meminfo (1100s) --- + -- Deprecated by the kernel in favour of SK_MEMINFO; kept for old kernels. + mem_info_rmem UInt32 CODEC(LZ4), + mem_info_wmem UInt32 CODEC(LZ4), + mem_info_fmem UInt32 CODEC(LZ4), + mem_info_tmem UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_INFO (2), struct tcp_info (1200s) ---------------- + -- Column names mirror the kernel member spelling (tcpi_rttvar -> tcp_info_rttvar). + tcp_info_state UInt32 CODEC(LZ4), + tcp_info_ca_state UInt32 CODEC(LZ4), + tcp_info_retransmits UInt32 CODEC(LZ4), + tcp_info_probes UInt32 CODEC(LZ4), + tcp_info_backoff UInt32 CODEC(LZ4), + tcp_info_options UInt32 CODEC(LZ4), + tcp_info_snd_wscale UInt32 CODEC(LZ4), + tcp_info_rcv_wscale UInt32 CODEC(LZ4), + tcp_info_delivery_rate_app_limited UInt32 CODEC(LZ4), + tcp_info_fastopen_client_fail UInt32 CODEC(LZ4), + tcp_info_rto UInt32 CODEC(LZ4), + tcp_info_ato UInt32 CODEC(LZ4), + tcp_info_snd_mss UInt32 CODEC(LZ4), + tcp_info_rcv_mss UInt32 CODEC(LZ4), + tcp_info_unacked UInt32 CODEC(LZ4), + tcp_info_sacked UInt32 CODEC(LZ4), + tcp_info_lost UInt32 CODEC(LZ4), + tcp_info_retrans UInt32 CODEC(LZ4), + tcp_info_fackets UInt32 CODEC(LZ4), + tcp_info_last_data_sent UInt32 CODEC(LZ4), + tcp_info_last_ack_sent UInt32 CODEC(LZ4), + tcp_info_last_data_recv UInt32 CODEC(LZ4), + tcp_info_last_ack_recv UInt32 CODEC(LZ4), + tcp_info_pmtu UInt32 CODEC(LZ4), + tcp_info_rcv_ssthresh UInt32 CODEC(LZ4), + tcp_info_rtt UInt32 CODEC(LZ4), + tcp_info_rttvar UInt32 CODEC(LZ4), + tcp_info_snd_ssthresh UInt32 CODEC(LZ4), + tcp_info_snd_cwnd UInt32 CODEC(LZ4), + tcp_info_advmss UInt32 CODEC(LZ4), + tcp_info_reordering UInt32 CODEC(LZ4), + tcp_info_rcv_rtt UInt32 CODEC(LZ4), + tcp_info_rcv_space UInt32 CODEC(LZ4), + tcp_info_total_retrans UInt32 CODEC(LZ4), + tcp_info_pacing_rate UInt64 CODEC(LZ4), + tcp_info_max_pacing_rate UInt64 CODEC(LZ4), + tcp_info_bytes_acked UInt64 CODEC(LZ4), + tcp_info_bytes_received UInt64 CODEC(LZ4), + tcp_info_segs_out UInt32 CODEC(LZ4), + tcp_info_segs_in UInt32 CODEC(LZ4), + tcp_info_notsent_bytes UInt32 CODEC(LZ4), + tcp_info_min_rtt UInt32 CODEC(LZ4), + tcp_info_data_segs_in UInt32 CODEC(LZ4), + tcp_info_data_segs_out UInt32 CODEC(LZ4), + tcp_info_delivery_rate UInt64 CODEC(LZ4), + tcp_info_busy_time UInt64 CODEC(LZ4), + tcp_info_rwnd_limited UInt64 CODEC(LZ4), + tcp_info_sndbuf_limited UInt64 CODEC(LZ4), + tcp_info_delivered UInt32 CODEC(LZ4), + tcp_info_delivered_ce UInt32 CODEC(LZ4), + tcp_info_bytes_sent UInt64 CODEC(LZ4), + tcp_info_bytes_retrans UInt64 CODEC(LZ4), + tcp_info_dsack_dups UInt32 CODEC(LZ4), + tcp_info_reord_seen UInt32 CODEC(LZ4), + tcp_info_rcv_ooopack UInt32 CODEC(LZ4), + tcp_info_snd_wnd UInt32 CODEC(LZ4), + tcp_info_rcv_wnd UInt32 CODEC(LZ4), + tcp_info_rehash UInt32 CODEC(LZ4), + tcp_info_total_rto UInt32 CODEC(LZ4), + tcp_info_total_rto_recoveries UInt32 CODEC(LZ4), + tcp_info_total_rto_time UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CONG (4) (1300s) --------------------------------- + -- inet_diag_cong is the kernel ca_ops->name string; inet_diag_cong_enum is + -- derived by xtcp from it (proto enum CongestionAlgorithm). + inet_diag_cong LowCardinality(String), + inet_diag_cong_enum Enum('' = 0, + 'cubic' = 1, + 'dctcp' = 2, + 'vegas' = 3, + 'prague' = 4, + 'bbr1' = 5, + 'bbr2' = 6, + 'bbr3' = 7 + ), + + -- ---- payload: INET_DIAG_TOS (5) / INET_DIAG_TCLASS (6) (1400s) ---------- + inet_diag_tos UInt32 CODEC(LZ4), + inet_diag_tclass UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SKMEMINFO (7), SK_MEMINFO_* (1500s) ------------- + sk_mem_info_rmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_rcvbuf UInt32 CODEC(LZ4), + sk_mem_info_wmem_alloc UInt32 CODEC(LZ4), + sk_mem_info_sndbuf UInt32 CODEC(LZ4), + sk_mem_info_fwd_alloc UInt32 CODEC(LZ4), + sk_mem_info_wmem_queued UInt32 CODEC(LZ4), + sk_mem_info_optmem UInt32 CODEC(LZ4), + sk_mem_info_backlog UInt32 CODEC(LZ4), + sk_mem_info_drops UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_SHUTDOWN (8) (1600s) ----------------------------- + inet_diag_shutdown UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_VEGASINFO (3), struct tcpvegas_info (1700s) ------ + vegas_info_enabled UInt32 CODEC(LZ4), + vegas_info_rttcnt UInt32 CODEC(LZ4), + vegas_info_rtt UInt32 CODEC(LZ4), + vegas_info_minrtt UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_DCTCPINFO (9), struct tcp_dctcp_info (1800s) ----- + dctcp_info_enabled UInt32 CODEC(LZ4), + dctcp_info_ce_state UInt32 CODEC(LZ4), + dctcp_info_alpha UInt32 CODEC(LZ4), + dctcp_info_ab_ecn UInt32 CODEC(LZ4), + dctcp_info_ab_tot UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_BBRINFO (16), struct tcp_bbr_info (1900s) -------- + bbr_info_bw_lo UInt32 CODEC(LZ4), + bbr_info_bw_hi UInt32 CODEC(LZ4), + bbr_info_min_rtt UInt32 CODEC(LZ4), + bbr_info_pacing_gain UInt32 CODEC(LZ4), + bbr_info_cwnd_gain UInt32 CODEC(LZ4), + + -- ---- payload: INET_DIAG_CLASS_ID (17) / SOCKOPT (22) / CGROUP_ID (21) (2000s) + inet_diag_class_id UInt32 CODEC(LZ4), + inet_diag_sockopt UInt32 CODEC(LZ4), + inet_diag_cgroup_id UInt64 CODEC(LZ4), +) +ENGINE = Kafka +SETTINGS + kafka_broker_list = 'redpanda-0:9092', + kafka_topic_list = 'xtcp', + kafka_group_name = 'xtcp', + -- ProtobufList format: kafka_schema MUST point at the ROW type + -- (XtcpFlatRecord), NOT the Envelope wrapper. ClickHouse's + -- ProtobufList handles the envelope framing internally; the schema + -- describes how each row's fields map to table columns. Pointing at + -- Envelope produces "NO_COLUMNS_SERIALIZED_TO_PROTOBUF_FIELDS" because + -- Envelope only has the single 'row' field. See: + -- build/containers/clickhouse/clickhouse_protolist_notes.md + -- + -- The message name here is the SIMPLE, unqualified type name + -- (XtcpFlatRecord) — do NOT prepend the proto package + -- (xtcp_flat_record.v1.). ClickHouse's ProtobufList resolver + -- (src/Formats/ProtobufSchemas.cpp) looks the name up via + -- FileDescriptor::FindMessageTypeByName, which expects the name + -- relative to the file's package; a package-qualified name such as + -- 'xtcp_flat_record.v1.XtcpFlatRecord' deterministically fails with + -- "Could not find a message named '...' in the schema file" + -- (BAD_ARGUMENTS), the consumer detaches, and ingestion stalls. + -- Regression introduced by 60da4c7 ("schema aligned with proto"), + -- reverted here. + kafka_schema = 'xtcp_flat_record.proto:XtcpFlatRecord', + kafka_format = 'ProtobufList', + kafka_max_rows_per_message = 10000, + kafka_num_consumers = 1, + kafka_thread_per_consumer = 0, + kafka_skip_broken_messages = 0, + kafka_handle_error_mode = 'stream', + -- ProtobufList already batches: each kafka message is an Envelope + -- containing ~100-1000 XtcpFlatRecord rows. The kafka_engine's + -- own Block accumulation (kafka_max_block_size, default 65,505 rows) + -- is therefore mostly redundant on top — it just holds rows in memory + -- across many kafka messages before pushing the MV. Combined with + -- the per-poll batch (kafka_poll_max_batch_size, 16 messages here), + -- a single MV flush at 65K rows was the source of 131 MiB chunk + -- allocations that tipped CH's per-server memory cap. + -- Settings: + -- kafka_poll_max_batch_size = 16 ~16 kafka messages per poll + -- kafka_max_block_size = 1024 ~1 envelope per flush + -- kafka_flush_interval_ms = 2000 backstop: flush at most every 2 s + -- With ~430 envelopeRows/sec from xtcp2 the Block fills in ~2.4 s on + -- average, so flushes happen at the row-threshold most of the time + -- and the time-backstop kicks in only when the producer is quiet. + kafka_max_block_size = 1024, + kafka_poll_max_batch_size = 16, + kafka_flush_interval_ms = 2000; + +-- 5. Re-create the per-epoch MVs (v0/v1 alias new -> old names; v2 positional). +-- Legacy bucket: pre-versioning daemons never set schema_version, so it decodes to +-- proto3 zero. Those rows land in _v0. Epoch 0 never sent enrichment fields, so +-- the aliased enrichment columns are always default here. +CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v0_mv TO xtcp.xtcp_flat_records_v0 + AS SELECT + schema_version, + daemon_version, + fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, + hostname, + location, + netns, + netns_inode, + nsid, + container_id, + container_runtime, + container_name, + container_image, + label, + tag, + record_counter, + socket_fd, + netlinker_id, + uplink1_ifname, + uplink1_nic_driver, + uplink1_nic_model, + uplink1_nic_pci_vendor, + uplink1_nic_pci_device, + uplink1_nic_bus_info, + uplink1_nic_speed_mbps, + uplink1_nic_fw_version, + uplink1_lldp_chassis_name, + uplink1_lldp_chassis_id, + uplink1_lldp_mgmt_ip, + uplink1_lldp_port_id, + uplink1_lldp_port_descr, + uplink2_ifname, + uplink2_nic_driver, + uplink2_nic_model, + uplink2_nic_pci_vendor, + uplink2_nic_pci_device, + uplink2_nic_bus_info, + uplink2_nic_speed_mbps, + uplink2_nic_fw_version, + uplink2_lldp_chassis_name, + uplink2_lldp_chassis_id, + uplink2_lldp_mgmt_ip, + uplink2_lldp_port_id, + uplink2_lldp_port_descr, + enrich_socket_interface_name, + toUInt8(enrich_socket_dest_locality) AS enrich_socket_dest_locality, + enrich_socket_dest_egress_ifindex, + enrich_socket_dest_egress_ifname, + enrich_socket_dest_asn, + enrich_socket_dest_next_hop_asn AS enrich_socket_next_hop_asn, + enrich_socket_dest_network_owner, + inet_diag_msg_family, + inet_diag_msg_state, + inet_diag_msg_timer, + inet_diag_msg_retrans, + inet_diag_msg_socket_source_port, + inet_diag_msg_socket_destination_port, + inet_diag_msg_socket_source, + inet_diag_msg_socket_destination, + inet_diag_msg_socket_interface, + inet_diag_msg_socket_cookie, + inet_diag_msg_expires, + inet_diag_msg_rqueue, + inet_diag_msg_wqueue, + inet_diag_msg_uid, + inet_diag_msg_inode, + mem_info_rmem, + mem_info_wmem, + mem_info_fmem, + mem_info_tmem, + tcp_info_state, + tcp_info_ca_state, + tcp_info_retransmits, + tcp_info_probes, + tcp_info_backoff, + tcp_info_options, + tcp_info_snd_wscale AS tcp_info_send_scale, + tcp_info_rcv_wscale AS tcp_info_rcv_scale, + tcp_info_delivery_rate_app_limited, + tcp_info_fastopen_client_fail AS tcp_info_fast_open_client_failed, + tcp_info_rto, + tcp_info_ato, + tcp_info_snd_mss, + tcp_info_rcv_mss, + tcp_info_unacked, + tcp_info_sacked, + tcp_info_lost, + tcp_info_retrans, + tcp_info_fackets, + tcp_info_last_data_sent, + tcp_info_last_ack_sent, + tcp_info_last_data_recv, + tcp_info_last_ack_recv, + tcp_info_pmtu, + tcp_info_rcv_ssthresh, + tcp_info_rtt, + tcp_info_rttvar AS tcp_info_rtt_var, + tcp_info_snd_ssthresh, + tcp_info_snd_cwnd, + tcp_info_advmss AS tcp_info_adv_mss, + tcp_info_reordering, + tcp_info_rcv_rtt, + tcp_info_rcv_space, + tcp_info_total_retrans, + tcp_info_pacing_rate, + tcp_info_max_pacing_rate, + tcp_info_bytes_acked, + tcp_info_bytes_received, + tcp_info_segs_out, + tcp_info_segs_in, + tcp_info_notsent_bytes AS tcp_info_not_sent_bytes, + tcp_info_min_rtt, + tcp_info_data_segs_in, + tcp_info_data_segs_out, + tcp_info_delivery_rate, + tcp_info_busy_time, + tcp_info_rwnd_limited, + tcp_info_sndbuf_limited, + tcp_info_delivered, + tcp_info_delivered_ce, + tcp_info_bytes_sent, + tcp_info_bytes_retrans, + tcp_info_dsack_dups, + tcp_info_reord_seen, + tcp_info_rcv_ooopack, + tcp_info_snd_wnd, + tcp_info_rcv_wnd, + tcp_info_rehash, + tcp_info_total_rto, + tcp_info_total_rto_recoveries, + tcp_info_total_rto_time, + inet_diag_cong AS congestion_algorithm_string, + toUInt8(inet_diag_cong_enum) AS congestion_algorithm_enum, + inet_diag_tos AS type_of_service, + inet_diag_tclass AS traffic_class, + sk_mem_info_rmem_alloc, + sk_mem_info_rcvbuf AS sk_mem_info_rcv_buf, + sk_mem_info_wmem_alloc, + sk_mem_info_sndbuf AS sk_mem_info_snd_buf, + sk_mem_info_fwd_alloc, + sk_mem_info_wmem_queued, + sk_mem_info_optmem, + sk_mem_info_backlog, + sk_mem_info_drops, + inet_diag_shutdown AS shutdown_state, + vegas_info_enabled, + vegas_info_rttcnt AS vegas_info_rtt_cnt, + vegas_info_rtt, + vegas_info_minrtt AS vegas_info_min_rtt, + dctcp_info_enabled, + dctcp_info_ce_state, + dctcp_info_alpha, + dctcp_info_ab_ecn, + dctcp_info_ab_tot, + bbr_info_bw_lo, + bbr_info_bw_hi, + bbr_info_min_rtt, + bbr_info_pacing_gain, + bbr_info_cwnd_gain, + inet_diag_class_id AS class_id, + inet_diag_sockopt AS sock_opt, + inet_diag_cgroup_id AS c_group + FROM xtcp.xtcp_flat_records_kafka + WHERE length(_error) == 0 AND schema_version = 0; + +-- Epoch 1 (XtcpFlatRecordSchemaVersion = 1). Same alias list as _v0_mv. Note the +-- three renumbered fields (egress_ifindex/ifname, cgroup id) cannot be recovered +-- for epoch-1 rows: the Kafka schema only knows their epoch-2 tags. +CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v1_mv TO xtcp.xtcp_flat_records_v1 + AS SELECT + schema_version, + daemon_version, + fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, + hostname, + location, + netns, + netns_inode, + nsid, + container_id, + container_runtime, + container_name, + container_image, + label, + tag, + record_counter, + socket_fd, + netlinker_id, + uplink1_ifname, + uplink1_nic_driver, + uplink1_nic_model, + uplink1_nic_pci_vendor, + uplink1_nic_pci_device, + uplink1_nic_bus_info, + uplink1_nic_speed_mbps, + uplink1_nic_fw_version, + uplink1_lldp_chassis_name, + uplink1_lldp_chassis_id, + uplink1_lldp_mgmt_ip, + uplink1_lldp_port_id, + uplink1_lldp_port_descr, + uplink2_ifname, + uplink2_nic_driver, + uplink2_nic_model, + uplink2_nic_pci_vendor, + uplink2_nic_pci_device, + uplink2_nic_bus_info, + uplink2_nic_speed_mbps, + uplink2_nic_fw_version, + uplink2_lldp_chassis_name, + uplink2_lldp_chassis_id, + uplink2_lldp_mgmt_ip, + uplink2_lldp_port_id, + uplink2_lldp_port_descr, + enrich_socket_interface_name, + toUInt8(enrich_socket_dest_locality) AS enrich_socket_dest_locality, + enrich_socket_dest_egress_ifindex, + enrich_socket_dest_egress_ifname, + enrich_socket_dest_asn, + enrich_socket_dest_next_hop_asn AS enrich_socket_next_hop_asn, + enrich_socket_dest_network_owner, + inet_diag_msg_family, + inet_diag_msg_state, + inet_diag_msg_timer, + inet_diag_msg_retrans, + inet_diag_msg_socket_source_port, + inet_diag_msg_socket_destination_port, + inet_diag_msg_socket_source, + inet_diag_msg_socket_destination, + inet_diag_msg_socket_interface, + inet_diag_msg_socket_cookie, + inet_diag_msg_expires, + inet_diag_msg_rqueue, + inet_diag_msg_wqueue, + inet_diag_msg_uid, + inet_diag_msg_inode, + mem_info_rmem, + mem_info_wmem, + mem_info_fmem, + mem_info_tmem, + tcp_info_state, + tcp_info_ca_state, + tcp_info_retransmits, + tcp_info_probes, + tcp_info_backoff, + tcp_info_options, + tcp_info_snd_wscale AS tcp_info_send_scale, + tcp_info_rcv_wscale AS tcp_info_rcv_scale, + tcp_info_delivery_rate_app_limited, + tcp_info_fastopen_client_fail AS tcp_info_fast_open_client_failed, + tcp_info_rto, + tcp_info_ato, + tcp_info_snd_mss, + tcp_info_rcv_mss, + tcp_info_unacked, + tcp_info_sacked, + tcp_info_lost, + tcp_info_retrans, + tcp_info_fackets, + tcp_info_last_data_sent, + tcp_info_last_ack_sent, + tcp_info_last_data_recv, + tcp_info_last_ack_recv, + tcp_info_pmtu, + tcp_info_rcv_ssthresh, + tcp_info_rtt, + tcp_info_rttvar AS tcp_info_rtt_var, + tcp_info_snd_ssthresh, + tcp_info_snd_cwnd, + tcp_info_advmss AS tcp_info_adv_mss, + tcp_info_reordering, + tcp_info_rcv_rtt, + tcp_info_rcv_space, + tcp_info_total_retrans, + tcp_info_pacing_rate, + tcp_info_max_pacing_rate, + tcp_info_bytes_acked, + tcp_info_bytes_received, + tcp_info_segs_out, + tcp_info_segs_in, + tcp_info_notsent_bytes AS tcp_info_not_sent_bytes, + tcp_info_min_rtt, + tcp_info_data_segs_in, + tcp_info_data_segs_out, + tcp_info_delivery_rate, + tcp_info_busy_time, + tcp_info_rwnd_limited, + tcp_info_sndbuf_limited, + tcp_info_delivered, + tcp_info_delivered_ce, + tcp_info_bytes_sent, + tcp_info_bytes_retrans, + tcp_info_dsack_dups, + tcp_info_reord_seen, + tcp_info_rcv_ooopack, + tcp_info_snd_wnd, + tcp_info_rcv_wnd, + tcp_info_rehash, + tcp_info_total_rto, + tcp_info_total_rto_recoveries, + tcp_info_total_rto_time, + inet_diag_cong AS congestion_algorithm_string, + toUInt8(inet_diag_cong_enum) AS congestion_algorithm_enum, + inet_diag_tos AS type_of_service, + inet_diag_tclass AS traffic_class, + sk_mem_info_rmem_alloc, + sk_mem_info_rcvbuf AS sk_mem_info_rcv_buf, + sk_mem_info_wmem_alloc, + sk_mem_info_sndbuf AS sk_mem_info_snd_buf, + sk_mem_info_fwd_alloc, + sk_mem_info_wmem_queued, + sk_mem_info_optmem, + sk_mem_info_backlog, + sk_mem_info_drops, + inet_diag_shutdown AS shutdown_state, + vegas_info_enabled, + vegas_info_rttcnt AS vegas_info_rtt_cnt, + vegas_info_rtt, + vegas_info_minrtt AS vegas_info_min_rtt, + dctcp_info_enabled, + dctcp_info_ce_state, + dctcp_info_alpha, + dctcp_info_ab_ecn, + dctcp_info_ab_tot, + bbr_info_bw_lo, + bbr_info_bw_hi, + bbr_info_min_rtt, + bbr_info_pacing_gain, + bbr_info_cwnd_gain, + inet_diag_class_id AS class_id, + inet_diag_sockopt AS sock_opt, + inet_diag_cgroup_id AS c_group + FROM xtcp.xtcp_flat_records_kafka + WHERE length(_error) == 0 AND schema_version = 1; + +-- Current format (XtcpFlatRecordSchemaVersion = 2). Column names match 1:1. +CREATE MATERIALIZED VIEW xtcp.xtcp_flat_records_v2_mv TO xtcp.xtcp_flat_records_v2 + AS SELECT + fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, + * EXCEPT (timestamp_ns) + FROM xtcp.xtcp_flat_records_kafka + WHERE length(_error) == 0 AND schema_version = 2; + +-- 6. Re-declare the Merge view AS the newest epoch. +DROP TABLE IF EXISTS xtcp.xtcp_flat_records; +CREATE TABLE IF NOT EXISTS xtcp.xtcp_flat_records + AS xtcp.xtcp_flat_records_v2 + ENGINE = Merge('xtcp', '^xtcp_flat_records_v[0-9]+$'); + +-- 7. Verify. +-- SELECT schema_version, count() FROM xtcp.xtcp_flat_records GROUP BY 1 ORDER BY 1; +-- SELECT * FROM system.kafka_consumers WHERE table = 'xtcp_flat_records_kafka' FORMAT Vertical; + +-- end diff --git a/build/containers/clickhouse/sql_queries.sql b/build/containers/clickhouse/sql_queries.sql index bd8c93b..c44702f 100644 --- a/build/containers/clickhouse/sql_queries.sql +++ b/build/containers/clickhouse/sql_queries.sql @@ -3,7 +3,7 @@ SELECT nsec, hostname, tcp_info_rtt, - tcp_info_rtt_var, + tcp_info_rttvar, tcp_info_min_rtt, tcp_info_rcv_rtt, FROM xtcp.xtcp_records diff --git a/build/k8s/clickhouse/bootstrap-mounted-configMap.cue b/build/k8s/clickhouse/bootstrap-mounted-configMap.cue index dda9f35..29aafdc 100644 --- a/build/k8s/clickhouse/bootstrap-mounted-configMap.cue +++ b/build/k8s/clickhouse/bootstrap-mounted-configMap.cue @@ -1,3 +1,10 @@ +// STALE (last regenerated 2025-03): this ConfigMap embeds a pre-epoch copy of +// the xtcp2 ClickHouse schema/DDL. Column names and field numbers have since +// changed (record epoch 2, 2026-09: kernel-spelled payload names, enrichment +// block, per-version _v0/_v1/_v2 tables). Do NOT apply as-is. Regenerate from +// build/containers/clickhouse/initdb.d/sql/ and +// build/containers/clickhouse/format_schemas/xtcp_flat_record.proto before use; +// see build/k8s/clickhouse/readme.md ("Schema staleness"). package bootstrap-mounted-configMap.cue apiVersion: "v1" diff --git a/build/k8s/clickhouse/bootstrap-mounted-configMap.yaml b/build/k8s/clickhouse/bootstrap-mounted-configMap.yaml index e25a14f..224585b 100644 --- a/build/k8s/clickhouse/bootstrap-mounted-configMap.yaml +++ b/build/k8s/clickhouse/bootstrap-mounted-configMap.yaml @@ -1,3 +1,10 @@ +# STALE (last regenerated 2025-03): this ConfigMap embeds a pre-epoch copy of +# the xtcp2 ClickHouse schema/DDL. Column names and field numbers have since +# changed (record epoch 2, 2026-09: kernel-spelled payload names, enrichment +# block, per-version _v0/_v1/_v2 tables). Do NOT apply as-is. Regenerate from +# build/containers/clickhouse/initdb.d/sql/ and +# build/containers/clickhouse/format_schemas/xtcp_flat_record.proto before use; +# see build/k8s/clickhouse/readme.md ("Schema staleness"). apiVersion: v1 kind: ConfigMap metadata: diff --git a/build/k8s/clickhouse/example.proto.configMap.yaml b/build/k8s/clickhouse/example.proto.configMap.yaml index 55d1453..e0a9a6f 100644 --- a/build/k8s/clickhouse/example.proto.configMap.yaml +++ b/build/k8s/clickhouse/example.proto.configMap.yaml @@ -1,3 +1,10 @@ +# STALE (last regenerated 2025-03): this ConfigMap embeds a pre-epoch copy of +# the xtcp2 ClickHouse schema/DDL. Column names and field numbers have since +# changed (record epoch 2, 2026-09: kernel-spelled payload names, enrichment +# block, per-version _v0/_v1/_v2 tables). Do NOT apply as-is. Regenerate from +# build/containers/clickhouse/initdb.d/sql/ and +# build/containers/clickhouse/format_schemas/xtcp_flat_record.proto before use; +# see build/k8s/clickhouse/readme.md ("Schema staleness"). apiVersion: v1 kind: ConfigMap metadata: diff --git a/build/k8s/clickhouse/flatxtcppb.proto.configMap.yaml b/build/k8s/clickhouse/flatxtcppb.proto.configMap.yaml index b968091..5b6999c 100644 --- a/build/k8s/clickhouse/flatxtcppb.proto.configMap.yaml +++ b/build/k8s/clickhouse/flatxtcppb.proto.configMap.yaml @@ -1,3 +1,10 @@ +# STALE (last regenerated 2025-03): this ConfigMap embeds a pre-epoch copy of +# the xtcp2 ClickHouse schema/DDL. Column names and field numbers have since +# changed (record epoch 2, 2026-09: kernel-spelled payload names, enrichment +# block, per-version _v0/_v1/_v2 tables). Do NOT apply as-is. Regenerate from +# build/containers/clickhouse/initdb.d/sql/ and +# build/containers/clickhouse/format_schemas/xtcp_flat_record.proto before use; +# see build/k8s/clickhouse/readme.md ("Schema staleness"). apiVersion: v1 kind: ConfigMap metadata: diff --git a/build/k8s/clickhouse/readme.md b/build/k8s/clickhouse/readme.md index 2c0e2c6..27d410c 100644 --- a/build/k8s/clickhouse/readme.md +++ b/build/k8s/clickhouse/readme.md @@ -123,3 +123,23 @@ kubectl -n clickhouse describe chk kubectl delete pod chi-clickhouse-inst-clickhouse-0-0-0 --grace-period=0 --force -n clickhouse for p in $(kubectl get pods | grep Terminating | awk '{print $1}'); do kubectl delete pod $p --grace-period=0 --force;done + +## Schema staleness + +The ConfigMaps in this directory (`bootstrap-mounted-configMap.{yaml,cue}`, +`example.proto.configMap.yaml`, `flatxtcppb.proto.configMap.yaml`) embed a copy +of the ClickHouse DDL and the `xtcp_flat_record.proto` format schema as they were +in 2025-03. They pre-date record versioning (`schema_version`, per-epoch +`_v0/_v1/_v2` tables) and the epoch-2 column renames, so they are **stale** and +must not be applied as-is. + +The source of truth is the compose stack: + +- DDL: `build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records{,_kafka,_mv}.sql` +- format schema: `build/containers/clickhouse/format_schemas/xtcp_flat_record.proto` + (generated by `nix run .#regen-protos`) +- migration for existing deployments: `build/containers/clickhouse/sql/migrations/v2.sql` + +Regenerate the ConfigMap payloads from those files (swap `MergeTree` for +`ReplicatedMergeTree` as the existing bootstrap script does) before deploying. +See `docs/record-versioning.md`. diff --git a/cmd/ipfeed-collector/DESIGN.md b/cmd/ipfeed-collector/DESIGN.md index 2d67c23..1f46ab0 100644 --- a/cmd/ipfeed-collector/DESIGN.md +++ b/cmd/ipfeed-collector/DESIGN.md @@ -4,25 +4,30 @@ `ipfeed-collector` fetches the authoritative cloud / CDN / SaaS **IP-range feeds** catalogued in the "Authoritative IP Address Sources" document, -normalizes every feed into a single record schema, and produces one combined -**Parquet** file that is uploaded to S3 under a timestamped key. The result is -an **IP → provider / service / region** classification dataset that can be -refreshed on a schedule (daily polling is reasonable; some feeds change less -often but polling is a cheap safety net). - -The tool is intentionally a **self-contained Go module** living under -`tools/ipfeed-collector/` in the `runpod/xtcp2` packaging repo. It does not -import the upstream `randomizedcoder/xtcp2` Go packages (they are consumed here -only as a Nix flake input), so it re-implements the small helpers it needs. +normalizes every feed into a single record schema, tags each record with a +representative ASN for its network owner, and produces one combined **Parquet** +file that is uploaded to S3 under a timestamped key. The result is an +**IP → provider / service / region / representative ASN** classification +dataset that can be refreshed on a schedule (the daemon defaults to every 6h; +some feeds change less often but polling is a cheap safety net). + +The tool lives in the `randomizedcoder/xtcp2` repo as `cmd/ipfeed-collector` +(main + bundled `sources/*.yaml`) plus the library packages under +`internal/ipfeed/` (`asnmap`, `combine`, `config`, `fetch`, `health`, `model`, +`output`, `parse`, `s3`, `summary`, `telemetry`). It shares the repo's +`go.mod` and Nix build, but is a leaf: nothing in `pkg/` or the xtcp2 daemon +imports `internal/ipfeed`. The consumer side is `pkg/ipasn`, which reads only +the Parquet artifact (see "Downstream consumer"). ## Goals 1. Download many feeds concurrently, with **retries + full-jitter exponential - backoff**. + backoff** and a bounded response-body size. 2. **Parse** each feed — formats vary widely (JSON with many schemas, CSV, plain-text CIDR lists, and one that requires URL discovery) — into a common normalized record. -3. Aggregate into a single combined dataset and write it as **Parquet**. +3. Validate, annotate with a representative ASN, aggregate into a single + combined dataset, and write it as **Parquet**. 4. **Upload to S3** with filename `YYYY-MM-DD-HH-MM.parquet` (UTC). 5. **OpenTelemetry (OTLP)** metrics + traces and **structured slog** logging. 6. Emit a **run summary**: files processed, records processed, with explicit @@ -33,58 +38,89 @@ only as a Nix flake input), so it re-implements the small helpers it needs. ## Non-goals -- Building an IP-lookup service or query API (this only produces the dataset). -- ASN/RPKI/BGP enrichment (Tier C in the source doc) — future work. +- Building an IP-lookup service or query API here (the lookup side is + `pkg/ipasn`, inside the xtcp2 daemon). +- Per-prefix BGP-origin or next-hop ASN, RPKI, or any BGP RIB (MRT) source — + the `asn` column is a lossy per-provider value (see "Representative ASN"). - Diffing / alerting on large changes between runs — noted as a follow-up. +- Conditional (ETag / If-Modified-Since) fetching with persisted per-source + state: `fetch.Client` supports it, but the collector currently fetches every + source unconditionally each cycle. ## Architecture ``` -sources/*.yaml ──▶ config.Load ──▶ []Source - │ (bounded worker pool, -concurrency) - ▼ - ┌── per source ────────────────────────────────┐ - │ fetch.Get (retry + backoff, ETag, discover) │ - │ │ raw bytes │ - │ ▼ │ - │ parse.Registry[source.Parser].Parse ──▶ rows │ - └────────────────────────────────┬──────────────┘ +sources/*.yaml ──▶ config.LoadDir ──▶ []config.Source (enabled, sorted, unique names) + │ (bounded worker pool, -concurrency) + ▼ + ┌── processSource, per source ──────────────────────┐ + │ fetch.Client.Discover (none | azure_download_page) │ + │ fetch.Client.Get (retry + backoff, 256 MiB cap)│ + │ │ raw bytes │ + │ ▼ │ + │ parse.Get(source.Parser).Parse ──▶ []model.Record │ + │ ▼ │ + │ combine.Validate (CIDR canonicalize, dedup, +/-) │ + └─────────────────────────────────┬──────────────────┘ + ▼ + summary.Summary.Add + concat valid records ▼ - combine.Combine (validate CIDRs, +/- boundaries) + asnmap.Annotate (network_owner/provider -> asn) + ▼ + sort by (prefix, source_name) ▼ output.WriteParquet (YYYY-MM-DD-HH-MM.parquet) ▼ - s3.Upload (minio-go v7) summary.Print + s3.Uploader.Put (minio-go v7) summary.Print (stdout) ``` Telemetry (OTel) and logging (slog) are threaded through every stage. ## Normalized record schema -Derived from the source document's recommended schema. Parquet columns: - -| column | notes | -|---|---| -| `prefix` | canonical CIDR string (validated) | -| `ip_version` | `4` or `6` | -| `network_owner` | who owns the routed space (e.g. `aws`) | -| `service_operator` | who operates the service (may differ from owner) | -| `provider` | source's provider label | -| `service` | service tag when the feed provides one | -| `product` | product/scope when provided | -| `region` | region/location when provided | -| `network_border_group` | AWS-specific, else empty | -| `direction` | ingress/egress when provided | -| `source_name` | source config `name` | -| `source_type` | provenance: `provider_feed`, `provider_api`, `provider_documentation`, … | -| `source_url` | feed URL actually fetched | -| `source_timestamp` | feed-declared publish time when available | -| `retrieved_at` | fetch time (UTC) | -| `confidence` | e.g. `authoritative` | +`internal/ipfeed/model.Record`, derived from the source document's recommended +schema. Parquet columns (struct tags double as the JSON names): +| column | type | notes | +|---|---|---| +| `prefix` | string | canonical masked CIDR (validated by `combine`) | +| `ip_version` | int32 | `4` or `6` (set by `combine`) | +| `asn` | uint32 | **representative** ASN of `network_owner` (fallback `provider`); `0` if unknown — see below | +| `network_owner` | string | who owns the routed space (e.g. `aws`) | +| `service_operator` | string | who operates the service (may differ from owner) | +| `provider` | string | source's provider label | +| `service` | string | service tag when the feed provides one | +| `product` | string | product/scope when provided | +| `region` | string | region/location when provided | +| `network_border_group` | string | AWS-specific, else empty | +| `direction` | string | ingress/egress when provided | +| `source_name` | string | source config `name` | +| `source_type` | string | provenance: `provider_feed`, `provider_api`, `provider_documentation`, … | +| `source_url` | string | feed URL from the source config | +| `source_timestamp` | string | feed-declared publish time when available | +| `retrieved_at` | string | fetch time (UTC, RFC3339) | +| `confidence` | string | e.g. `authoritative` | + +Empty strings mean "not provided by this feed" — values are never invented. Overlapping records are **kept** — an address can legitimately be AWS-owned and Atlassian-operated at once. We do not collapse to one provider per prefix. +### Representative ASN + +`internal/ipfeed/asnmap` holds a small curated table from lowercased +`network_owner` / `provider` spellings to a provider's primary public ASN +(`aws`/`amazon` → 16509, `google`/`gcp` → 15169, `microsoft`/`azure` → 8075, +`cloudflare` → 13335, `fastly` → 54113, `apple` → 714, `digitalocean` → 14061, +`github` → 36459, `oracle` → 31898, `salesforce` → 14340, `atlassian` → 133530). +`Annotate` sets `asn` on every combined record whose owner (then provider) +matches; unmatched records stay `0`. + +This is deliberately **lossy**: the feeds identify a prefix's *owner*, not its +BGP-origin ASN, and large providers announce from several ASNs (AWS also uses +AS14618/AS8987; Google also AS36040/AS36384). Treat `asn` as "the provider's +representative ASN", exact only in the sense that the owner is exact. True +per-prefix origin/next-hop ASN needs a BGP RIB source and is a separate phase. + ## Source configuration (one YAML per feed) ```yaml @@ -102,20 +138,28 @@ parser_opts: {} # parser-specific options (CSV columns, etc.) enabled: true ``` -Adding a feed = drop a new YAML in `sources/`. Removing = delete it (or set -`enabled: false`). The tool globs `sources/*.yaml`, validates each config, and -fans work out across a bounded worker pool. +Adding a feed = drop a new YAML in `cmd/ipfeed-collector/sources/`. Removing = +delete it (or set `enabled: false`). `config.LoadDir` stats the directory +(clear error if missing or not a directory), globs `*.yaml` and `*.yml`, +decodes with unknown keys rejected, validates each file (required `name`, +`url`, `parser`; registered parser; known `discover` mode), rejects duplicate +`name`s across files, drops disabled sources, and returns the rest sorted by +name. Any single bad file fails the whole load so a broken config fails fast +rather than silently dropping a feed. ## Parsers -A registry maps the `parser:` key to a `Parser` implementation. Simple shapes -are handled by config-driven generic parsers; novel JSON schemas get a small -dedicated parser. +`internal/ipfeed/parse` keeps a registry mapping the `parser:` key to a +`Parser` implementation (`Parse(data []byte, meta SourceMeta, retrievedAt +string) ([]model.Record, error)`). Simple shapes are handled by config-driven +generic parsers; novel JSON schemas get a small dedicated parser. Parsers only +set feed-derived fields on top of `SourceMeta.Base`; CIDR validation and +`ip_version` derivation happen later in `combine`. | parser key | feeds | shape | |---|---|---| | `text_cidr` | Cloudflare v4/v6 | one CIDR per line | -| `csv` | DigitalOcean, Apple Private Relay, AWS geo-feed | column map in `parser_opts` | +| `csv` | DigitalOcean, Apple Private Relay, AWS geo-feed | column map in `parser_opts` (`has_header`, `prefix_column`, `region_column`, …) | | `aws_ip_ranges` | AWS | `prefixes[]`/`ipv6_prefixes[]` + service/region/network_border_group | | `gcp_ipranges` | GCP cloud.json/goog.json | `prefixes[].ipv4Prefix/ipv6Prefix`, scope, service | | `oci` | Oracle | `regions[].cidrs[].cidr` + tags | @@ -123,36 +167,50 @@ dedicated parser. | `github_meta` | GitHub `/meta` | object of named arrays → `service` | | `atlassian` | Atlassian | `items[]` w/ cidr, product, region, direction | | `salesforce` | Salesforce Hyperforce | prefixes + direction | -| `applebot` / `google_crawlers` | Apple, Google crawlers | `prefixes[].ipv4Prefix/ipv6Prefix` | +| `applebot` / `google_crawlers` | Apple, Google crawlers | `prefixes[].ipv4Prefix/ipv6Prefix` (shares the `gcp_ipranges` implementation) | | `m365` | Microsoft 365 | areas array, each with `ips[]` + serviceArea | | `azure_service_tags` | Azure | discover current dated JSON, then `values[].properties.addressPrefixes` | -New provider with a novel schema = add one `parse/json_x.go`, register it, add a -YAML. New feed that reuses an existing shape = YAML only. +New provider with a novel schema = add one `internal/ipfeed/parse/json_x.go`, +register it in its `init()`, add a YAML. New feed that reuses an existing shape += YAML only. ## Fetch: retries, backoff, robustness -- A single reused `*http.Client` with a configured timeout; per-request - `context.WithTimeout` + `http.NewRequestWithContext`. -- **Full-jitter exponential backoff** on retryable failures (network errors, - timeouts, HTTP 5xx / 429): window `= base << (attempt-1)` clamped to a cap; - the actual sleep is drawn uniformly in `[0, window]` from `crypto/rand`, and +- A single reused `*http.Client` with the `-timeout` value as its overall + per-request timeout; requests are built with `http.NewRequestWithContext` so + the cycle context cancels in-flight fetches. +- **Full-jitter exponential backoff** on retryable failures (transport errors, + HTTP 5xx / 429): window `= base << (attempt-1)` clamped to a cap; + the actual sleep is drawn uniformly in `[0, window)` from `crypto/rand`, and the sleep is context-aware. Configurable `-max-attempts`, `-backoff-base`, `-backoff-cap`. The jitter and sleep are injectable seams so tests are - deterministic and never actually sleep. -- Optional `ETag` / `Last-Modified` conditional requests (per-source state); - a `304 Not Modified` reuses the prior parse where a state file exists. -- **Never accept an empty/invalid response**: a non-2xx status, or a body that - yields zero valid records, marks that source **failed** — it contributes - nothing to the combined dataset. + deterministic and never actually sleep. Other 4xx fail immediately; a + malformed URL or a canceled context is terminal. +- **Bounded body:** a 2xx body is read through `io.LimitReader` capped at + 256 MiB (`fetch.maxBodyBytes`). Exactly the limit is accepted; anything + larger fails with `fetch.ErrBodyTooLarge` and is *not* retried (it would be + just as large next time), so a runaway feed cannot OOM the collector. +- `ETag` / `Last-Modified` are captured on the `Result` and `Get` accepts a + `Conditional`, but the collector passes an empty one — there is no persisted + per-source state yet (see Non-goals). +- **Never accept an empty/invalid response**: a discover or fetch error, a + parse error, or a body that yields zero valid records marks that source + **failed** (logged with `source` + `err`, carried into the summary `note`) — + it contributes nothing to the combined dataset. ## Combine + positive/negative boundaries -- Each parsed row's `prefix` is validated with `net/netip.ParsePrefix`. +- Each parsed row's `prefix` is validated with `net/netip.ParsePrefix`, then + masked and canonicalized (`1.2.3.4/24` → `1.2.3.0/24`); `ip_version` is set. - **Positive (+)** = a valid CIDR that passes validation → included in output. - **Negative (−)** = rejected → counted with a bounded reason enum so metric cardinality stays safe (raw error text is never used as a label): `ParseError`, `Empty`, `Duplicate`, `SourceFailed`. +- Duplicates are detected on `prefix` + the classification fields + (`network_owner`, `service_operator`, `service`, `product`, `region`, + `direction`, `source_name`), so the same prefix under a different + service/region is intentionally kept. - The combined dataset is written only if at least `-min-successful-sources` succeeded, so a bad run never overwrites good data downstream. @@ -171,33 +229,77 @@ YAML. New feed that reuses an existing shape = YAML only. - Credentials/region resolve flag > `IPFEED_S3_*` env > standard `AWS_*` env (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`) > default, so an existing AWS SDK/CLI environment works unmodified. -- The uploader sits behind a small interface so tests use a fake. The S3 key is - `<-s3-prefix>/` (the timestamped name, or the `-out-file` basename). +- The uploader sits behind the `s3.Uploader` interface so tests use a fake. The + S3 key is `<-s3-prefix>/` (the timestamped name, or the `-out-file` + basename). - `-no-upload` performs a dry run (local Parquet only). -## Telemetry (OTel / OTLP) - -- OTLP metric + trace exporters via the OTel SDK; endpoint from the standard - `OTEL_EXPORTER_OTLP_ENDPOINT` env. Resource `service.name=ipfeed-collector`. - Providers are flushed/shut down gracefully at exit. -- Instruments (attributes `source`, `provider`): counters `fetch.bytes`, - `fetch.attempts`, `fetch.failures`, `records.valid`, `records.invalid`, - `upload.bytes`, and `cycles` (attribute `outcome=success|failure`, for daemon - health); histograms `fetch.duration`, `parse.duration`; gauge - `sources.succeeded`. -- Trace spans: a root run span, a per-source span (with fetch/parse children), - and combine + upload spans. +## Downstream consumer + +`pkg/ipasn` (in this repo) is the read side. It loads the artifact's `prefix`, +`asn`, and `network_owner` columns into a `github.com/gaissmai/bart` +longest-prefix-match table, swapped atomically on reload so lookups on the +xtcp2 per-socket hot path never block or see a half-built table. The xtcp2 +daemon uses it to fill `enrich_socket_dest_asn` and +`enrich_socket_dest_network_owner`; the daemon flags `-enrichAsn`, +`-asnDbPath`, `-asnRefreshInterval` (env `ENRICH_ASN`, `ASN_DB_PATH`, +`ASN_REFRESH_INTERVAL`) are being added alongside this work. The end-to-end +design is in `docs/ipfeed-asn-enrichment.md`. + +## Telemetry (OTel / OTLP / Prometheus) + +- One set of OTel instruments, two exporters. OTLP metric + trace exporters via + the OTel SDK; endpoint from the standard `OTEL_EXPORTER_OTLP_ENDPOINT` env + (no exporter when unset). In daemon mode with `-http-addr`, + `telemetry.Setup` is called with `Options{Prometheus: true}`, which adds the + `go.opentelemetry.io/otel/exporters/prometheus` pull reader on a **private** + `prometheus.Registry` and hands back `Telemetry.PrometheusHandler`; `run` + mounts it as `/metrics` on the health server (`health.Server.Handle`). A + private registry keeps two `Setup`s in one process (tests) from colliding. + Resource `service.name=ipfeed-collector`. Providers are flushed/shut down + gracefully at exit. +- Per-source instruments (attributes `source`, `provider`): counters + `ipfeed.fetch.bytes`, `ipfeed.fetch.attempts`, `ipfeed.fetch.failures`, + `ipfeed.records.valid`, `ipfeed.records.invalid`; histograms + `ipfeed.fetch.duration` (discover + download), `ipfeed.parse.duration` + (seconds); gauge `ipfeed.source.records` — valid prefix entries the source + contributed in the latest cycle, recorded for every source each cycle (0 for + a failed one) so a feed that stops contributing is visible rather than frozen + at its last value. +- Per-cycle instruments: counter `ipfeed.cycles` and histogram + `ipfeed.cycle.duration` (attribute `outcome=success|failure`); gauges + `ipfeed.sources.succeeded`, `ipfeed.artifact.records` (entries in the Parquet + artifact just written — the lookup-table size the xtcp2 daemon will load) and + `ipfeed.artifact.size` (unit `By`); histograms `ipfeed.write.duration` (sort + + Parquet write, recorded even when the write fails) and `ipfeed.upload.duration` + (S3 PUT); counter `ipfeed.upload.bytes`. +- Prometheus rendering: dotted names become underscored with the conventional + suffixes (`ipfeed_fetch_duration_seconds`, `ipfeed_cycles_total`, + `ipfeed_artifact_size_bytes`), plus the exporter's `otel_scope_name` / + `otel_scope_version` labels and a `target_info` series. The instrument is + named `artifact.size`, not `artifact.bytes`, precisely so the unit suffix does + not double up. The operator-facing table is in `README.md`. +- Trace spans: `cycle` (root, per collection), `source` (one per source, + attribute `source`), and `upload` (attribute `key`). +- The consumer side of the same table (`pkg/xtcp` `loadAsn`: entries loaded, + artifact bytes, load time, build duration) is documented in + `docs/ipfeed-asn-enrichment.md`. ## Logging -Structured `slog` (JSON handler); verbosity via `-v` / `-debug`. Common fields: -`source`, `url`, `status`, `bytes`, `dur`. Secrets are never logged. +Structured `slog` (JSON handler on stderr); verbosity via `-v` / `-debug`. +Common fields: `source`, `parser`, `url`, `http`, `bytes`, `valid`, +`rejected`, `err`. Every per-source failure (discover, fetch, parse, no valid +records) is logged with the source name and the error. Secrets are never +logged. ## Run summary -Printed to stdout and logged at end — a per-source table plus totals showing -files processed, records processed, and the +valid / −rejected boundaries; -process exits non-zero if fewer than `-min-successful-sources` succeeded. +Printed to stdout at the end of each cycle — a per-source table (`status`, +`http`, `fetched`, `parsed`, `+valid`, `-rejected`, `dur`, `note`) plus totals +showing sources ok/fail and the +valid / −rejected record boundaries, and the +uploaded `s3://` URL when an upload happened. The process exits non-zero if +fewer than `-min-successful-sources` succeeded (the summary is still printed). ## Run modes (single-shot & daemon) @@ -220,9 +322,9 @@ long-running services. authoritative and there is no spurious final cycle. - **Fault tolerance:** a failed cycle is logged and the loop continues (a transient upstream outage does not kill the daemon). Each cycle records the - `cycles` counter with `outcome=success|failure`. - - **Hot reload:** every cycle re-globs `sources/`, so feeds can be added or - removed without restarting. + `ipfeed.cycles` counter with `outcome=success|failure`. + - **Hot reload:** every cycle re-reads `-sources-dir`, so feeds can be added + or removed without restarting. `runDaemon` takes plain `collect`/`ready` function seams (no telemetry or HTTP types) so it is tested deterministically: the fake `collect` cancels the context @@ -231,127 +333,134 @@ transitions without sleeping on real timers. ### Health endpoints -When `-http-addr` is set, the daemon starts an HTTP server (via the `health` -package) exposing `/healthz` (liveness — always `200` once bound) and `/readyz` -(readiness — `200` only after ≥1 successful cycle, else `503`). Readiness is an -`atomic.Bool` flipped by the daemon after each successful cycle, letting an -orchestrator hold traffic/alerts until the first dataset exists. `Start` binds -the listener synchronously so a bad `-http-addr` fails fast; serving runs in a -background goroutine and is stopped by `Shutdown` on exit. +When `-http-addr` is set, the daemon starts an HTTP server (via the +`internal/ipfeed/health` package) exposing `/healthz` (liveness — always `200` +once bound), `/readyz` (readiness — `200` only after ≥1 successful cycle, +else `503`) and `/metrics` (the Prometheus handler from the telemetry +package, mounted through `Server.Handle` before `Start`). Readiness is an +`atomic.Bool` flipped by the daemon after each +successful cycle, letting an orchestrator hold traffic/alerts until the first +dataset exists. `Start` binds the listener synchronously so a bad `-http-addr` +fails fast; serving runs in a background goroutine and is stopped by +`Shutdown` on exit. ## Configuration (flags + env) Configuration is stdlib `flag` with an `IPFEED_*` environment-variable fallback -per flag. Precedence is **CLI flag > `IPFEED_*` env > built-in default**. The S3 -credential and region flags insert the standard `AWS_*` names between their -`IPFEED_S3_*` env and the default (**flag > `IPFEED_S3_*` > `AWS_*` > default**). -An invalid env value falls back to the built-in default rather than erroring, so -a malformed variable cannot crash-loop the daemon. Daemon mode additionally -validates `-interval > 0` at startup. See the README for the full flag ↔ env -mapping. +per flag (except `-version`). Precedence is **CLI flag > `IPFEED_*` env > +built-in default**. The S3 credential and region flags insert the standard +`AWS_*` names between their `IPFEED_S3_*` env and the default (**flag > +`IPFEED_S3_*` > `AWS_*` > default**). An invalid env value falls back to the +built-in default rather than erroring, so a malformed variable cannot +crash-loop the daemon. Daemon mode additionally validates `-interval > 0` at +startup; a failed validation is printed to stderr and exits 2. See the README +for the full flag ↔ env mapping. ## Testing -All unit tests are **table-driven**; each row carries a `name`, a -human-readable `desc`, the input, `want`, and `wantErr` (expected outcome), and -every table explicitly covers **positive, negative, boundary, and corner** -cases (see the repo test standard). Parser tables use small `testdata/` -fixtures; fetch/backoff and S3 tests use injected seams and fakes so they are -deterministic and offline. +All unit tests are **table-driven**; each row carries a human-readable +`description`, the input, and explicit expected-outcome fields, and every +table covers **positive, negative, boundary, and corner** cases (see the repo +test standard). Parser tables use small inline fixtures (there is no +`testdata/` directory); fetch/backoff tests use `httptest` plus the injected +jitter/sleep seams, and the body-size cap is exercised by lowering +`fetch.maxBodyBytes` in-test rather than streaming 256 MiB. Config tests build +temporary source directories per row. ### Race tests -Concurrency is exercised under the Go race detector (`go test -race ./...`), -with tests that give it real shared state to inspect: the health server's +Concurrency is exercised under the Go race detector (`go test -race`), with +tests that give it real shared state to inspect: the health server's `atomic.Bool` readiness (many goroutines calling `SetReady()` while others -serve `/readyz`), the `collectOnce` worker-pool fan-in (concurrent -`processSource` results aggregated into shared slices/summary), and concurrent -`fetch.Client.Get` calls sharing one `*Client`. The race detector **requires -cgo**, so the Nix `race` check compiles with `CGO_ENABLED=1` and a C toolchain -on PATH — the one place the pipeline diverges from the default `CGO_ENABLED=0` -static build. +serve `/readyz`) and concurrent `fetch.Client.Get` calls sharing one `*Client` +through a retry. The race detector **requires cgo**, so the Nix +`test-go-race` runner (`nix build .#test-go-race`, whole-repo +`go test -race ./...`) compiles with `CGO_ENABLED=1` and gcc on PATH — the one +place the pipeline diverges from the default `CGO_ENABLED=0` static build. ### Benchmarks -Go benchmarks cover the hot paths: `internal/parse` (per-format decode over -`testdata/` fixtures), `internal/combine` `Validate` (CIDR parse + -canonicalization + dedup over 1e2 / 1e4 / 1e5 records — the hottest path at -~17k+ records/run), and `internal/output` `WriteParquet` throughput. Each uses +Go benchmarks cover the hot paths: `internal/ipfeed/parse` (`BenchmarkParse`, +per-format decode), `internal/ipfeed/combine` (`BenchmarkValidate`: CIDR parse ++ canonicalization + dedup, size-swept — the hottest path at ~17k+ +records/run), and `internal/ipfeed/output` (`BenchmarkWriteParquet`). Each uses `b.ReportAllocs()` and size-swept `b.Run` sub-benchmarks (the table-driven -analog for benches). Perf *numbers* are gathered on a real host with -`benchstat`; the Nix `bench-smoke` check only runs `-benchtime=1x` to prove -benchmarks build and execute (the build sandbox is not a stable perf -environment). +analog for benches). Run them directly with +`go test -bench=. -benchmem -run='^$' ./internal/ipfeed/...` and compare with +`benchstat`; the Nix `test-go-bench` target only benches `pkg/xtcpnl` and does +not cover these packages. ## Build & packaging (Nix) -The tool ships a **self-contained flake** under `tools/ipfeed-collector/` -(alongside its own `go.mod`), mirroring the upstream `xtcp2` Nix layout but -without its protos/giouring/microvm/flavor machinery — this is a single -standalone binary. The repo-root RunPod flake (which re-exports the upstream -s3parquet image) is intentionally left untouched. +The collector is built by the repo-root flake (`flake.nix` → `nix/default.nix`), +not a flake of its own. Relevant pieces: ``` -tools/ipfeed-collector/ - flake.nix # thin orchestrator -> ./nix (eachSystem x86_64-linux) - nix/ - default.nix # per-system aggregator: packages, devShells, checks - versions.nix # Go pin + buildVariants {debug, compact} + goVendorHash - packages.nix # dev tool list - devshell.nix # `nix develop` + helpers, via `ipfeed-help` - lib/mkGoBinary.nix # reusable buildGoModule wrapper (consumed by OCI) - lib/mkOciImage.nix # scratch streamLayeredImage wrapper - containers/default.nix # oci-ipfeed-collector (compact) + -debug - checks/default.nix # gofmt, vet, test, race, bench-smoke +flake.nix # thin orchestrator -> ./nix (per-system aggregator) +nix/ + default.nix # packages / devShells / checks / apps aggregator + versions.nix # Go pin (go_1_26 overridden to 1.26.5), buildVariants, goVendorHash + binaries.nix # binaryNames includes "ipfeed-collector" -> packages.ipfeed-collector + lib/mkGoBinary.nix # buildGoModule wrapper: static, -trimpath, -X main.{version,commit,date} + lib/mkOciImage.nix # scratch streamLayeredImage + dockerTools.caCertificates + containers/default.nix # oci-ipfeed-collector (Cmd -daemon -http-addr :8080, HEALTHCHECK) + checks/ # gofmt, go-vet, golangci-lint*, go-sec, cli-help-smoke (runs `ipfeed-collector -h`), … + tests/ # test-go-race (whole repo, CGO), test-go-bench (pkg/xtcpnl only), … ``` ### Build variants -`versions.nix` defines two variants that drive `mkGoBinary`: +`versions.nix` defines three variants that drive `mkGoBinary`: | variant | ldflags | strip | use | |---|---|---|---| | `debug` | none (keeps symbols + DWARF) | no | delve / `pprof` symbolization, post-mortems | -| `compact` | `-s -w` | yes (`binutils strip`) | production default; smallest image | +| `default` | `-s -w` | no | production default (`packages.ipfeed-collector`) | +| `stripped` | `-s -w` | yes (`binutils strip`) | smallest possible binary | -Builds are static (`CGO_ENABLED=0`, tags `netgo,osusergo`) with `-trimpath` and -`-X main.{version,commit,date}` injected. The Go toolchain is pinned to match -`go.mod` (1.26.x). +Only the `default` variant is exposed as a top-level package for +`ipfeed-collector`; the `-debug` / `-stripped` top-level attrs exist for +`xtcp2` only. Builds are static (`CGO_ENABLED=0`) with `-trimpath` and +`-X main.{version,commit,date}` injected (`version` comes from the repo-root +`VERSION` file). The Go toolchain is pinned in `versions.nix` (1.26.x; `go.mod` +declares `go 1.25.0` as the minimum). ### Reusable Go-binary derivation `lib/mkGoBinary.nix` wraps `buildGoModule` (overridden to the pinned Go), -building `cmd/ipfeed-collector` with the requested variant. It is the single -source of the compiled binary and is **reused by the OCI images** so the image -contents are byte-identical to `nix build .#ipfeed-collector`. The module has -no local `replace` directives, so no `go.mod` patching is needed; `vendorHash` -lives in `versions.nix` (bootstrap with `lib.fakeHash`, then paste the reported -`got: sha256-…`). +building `cmd/ipfeed-collector` from the shared vendored module set +(`goVendorHash` in `versions.nix`). It is the single source of the compiled +binary and is **reused by the OCI image** so the image contents are +byte-identical to `nix build .#ipfeed-collector`. -### OCI images +### OCI image `lib/mkOciImage.nix` uses `dockerTools.streamLayeredImage` over a scratch base plus `dockerTools.caCertificates` (HTTPS to real feeds and S3 needs a CA -bundle; `SSL_CERT_FILE` is pointed at it). Two images: +bundle; `SSL_CERT_FILE` is pointed at it). One image: -- `oci-ipfeed-collector` — compact variant, `tag=latest`. -- `oci-ipfeed-collector-debug` — debug variant, `tag=debug`. +- `oci-ipfeed-collector` — default variant, `tag=latest`. -Entrypoint is `/bin/ipfeed-collector` with `Cmd=["-daemon"]`, so a bare -`docker run` starts the service (all `IPFEED_*` env overridable at runtime); the -health port is exposed by convention. The image carries a Docker **HEALTHCHECK** -(`/bin/ipfeed-collector -healthcheck`) — a self-probe mode that issues an HTTP -GET to `127.0.0.1/readyz` and exits `0`/`1`, so the scratch image -needs no shell or `curl` (mirrors upstream xtcp2's `-healthcheck`). +Entrypoint is `/bin/ipfeed-collector` with +`Cmd=["-daemon", "-http-addr", ":8080"]` and port `8080` exposed, so a bare +`docker run` starts the daemon with health endpoints (all `IPFEED_*` env +overridable at runtime). Feed definitions are **not** baked in: mount a +directory and set `IPFEED_SOURCES_DIR`. The image carries a Docker +**HEALTHCHECK** (`/bin/ipfeed-collector -healthcheck`, interval 30s, timeout +5s, start period 15s, 3 retries) — a self-probe mode that issues an HTTP GET to +`127.0.0.1:8080/readyz` and exits `0`/`1`, so the scratch image needs no shell +or `curl` (mirrors the xtcp2 daemon's `-healthcheck`). Load with `nix build .#oci-ipfeed-collector && ./result | docker load`. ### Dev shell -`nix develop` lands in a shell with the pinned Go plus `gopls`, -`golangci-lint`, `delve`, `benchstat`, and `nixfmt`. Helper functions -(discoverable via `ipfeed-help`) wrap the common loops: `build`, `test`, -`test-race`, `bench`, `bench-compare`, `lint`. +`nix develop` (repo root) lands in the shared xtcp2 shell with the pinned Go +plus `gopls`, `golangci-lint`, `delve`, `nixfmt`, and the proto toolchain. +Helper functions (discoverable via `xtcp2-help`) wrap the common repo-wide +loops: `lint-quick`, `lint`, `lint-comprehensive`, `lint-fix`, `lint-new`, +`regen-protos`. There are no ipfeed-specific helpers; use the `go` commands in +the README. Wiring the image into the RunPod release pipeline and adding a committed PGO -profile are noted follow-ups, out of scope for the initial packaging. +profile are noted follow-ups. diff --git a/cmd/ipfeed-collector/README.md b/cmd/ipfeed-collector/README.md index 3a0fcbc..a9ca901 100644 --- a/cmd/ipfeed-collector/README.md +++ b/cmd/ipfeed-collector/README.md @@ -1,99 +1,138 @@ # ipfeed-collector Fetches authoritative cloud / CDN / SaaS **IP-range feeds**, normalizes them -into one schema, writes a combined **Parquet** file named `YYYY-MM-DD-HH-MM` +into one schema, tags each prefix with a *representative* ASN for its network +owner, writes a combined **Parquet** file named `YYYY-MM-DD-HH-MM.parquet` (UTC), and uploads it to S3. Emits OpenTelemetry (OTLP) metrics/traces, structured `slog` logs, and an end-of-run summary with positive/negative (valid vs rejected) record boundaries. +The artifact is consumed by the xtcp2 daemon via `pkg/ipasn` for per-socket +destination ASN / network-owner enrichment (see "Output" below). + See [DESIGN.md](./DESIGN.md) for the full design. ## Build & test +The collector is part of the `github.com/randomizedcoder/xtcp2` module: +`cmd/ipfeed-collector` (main + bundled `sources/`) and `internal/ipfeed/*` +(the library packages). From the repo root: + ```sh -cd tools/ipfeed-collector -go build ./... -go vet ./... -go test ./... -go test -race ./... # race detector (needs cgo) -go test -bench=. -benchmem -run='^$' ./... # benchmarks +go build ./cmd/ipfeed-collector +go vet ./cmd/ipfeed-collector/... ./internal/ipfeed/... +go test ./cmd/ipfeed-collector/... ./internal/ipfeed/... +go test -race ./cmd/ipfeed-collector/... ./internal/ipfeed/... # race detector (needs cgo) +go test -bench=. -benchmem -run='^$' ./internal/ipfeed/... # benchmarks ``` ## Build with Nix -The tool has a self-contained flake. From `tools/ipfeed-collector/`: +The collector is built by the repo-root flake (`flake.nix` -> `nix/`), which +enumerates it in `nix/binaries.nix` alongside the other `cmd/*` binaries. +From the repo root: ```sh -nix develop # dev shell (Go, gopls, golangci-lint, delve); run `ipfeed-help` -nix build .#ipfeed-collector # static binary (compact: -s -w + strip) -nix build .#ipfeed-collector-debug # static binary with symbols + DWARF (delve/pprof) -nix build .#oci-ipfeed-collector # scratch OCI image (compact) -nix build .#oci-ipfeed-collector-debug # scratch OCI image (debug) -./result | docker load # load a built image -nix flake check # gofmt + vet + test + race + bench-smoke +nix develop # dev shell (Go, gopls, golangci-lint, delve, …); run `xtcp2-help` +nix build .#ipfeed-collector # static binary, default variant (-s -w) +nix build .#oci-ipfeed-collector # scratch OCI image (daemon) +./result | docker load # load the built image +nix build .#test-go-race # whole-repo `go test -race ./...` (CGO_ENABLED=1) +nix flake check # repo-wide gofmt / go-vet / golangci-lint / gosec / … checks ``` -The OCI images are scratch + a CA bundle; entrypoint is `/bin/ipfeed-collector` -with a default `-daemon` arg and a Docker HEALTHCHECK wired to `-healthcheck`. -See [DESIGN.md](./DESIGN.md) "Build & packaging (Nix)" for details. +There is no separate `ipfeed-collector-debug` package or debug image; the +`debug` / `stripped` build variants exist internally (`nix/versions.nix`) and +are exposed only for `xtcp2` (`xtcp2-debug`, `xtcp2-stripped`). + +The OCI image is scratch + a CA bundle; entrypoint is `/bin/ipfeed-collector` +with `Cmd=["-daemon", "-http-addr", ":8080"]`, port `8080` exposed, and a Docker +HEALTHCHECK wired to `-healthcheck`. Feed definitions are **not** baked into the +image: mount a directory of YAML files and point `-sources-dir` / +`IPFEED_SOURCES_DIR` at it. See [DESIGN.md](./DESIGN.md) "Build & packaging +(Nix)" for details. ## Run -Dry run (no upload) against the bundled sources: +Dry run (no upload) against the bundled sources, from the repo root: ```sh -go run ./cmd/ipfeed-collector -sources-dir ./sources -out-dir /tmp -no-upload +go run ./cmd/ipfeed-collector -sources-dir ./cmd/ipfeed-collector/sources -out-dir /tmp -no-upload ``` Write to an exact local path and skip S3 entirely: ```sh -go run ./cmd/ipfeed-collector -sources-dir ./sources -out-file /data/ipfeeds.parquet -no-upload +go run ./cmd/ipfeed-collector -sources-dir ./cmd/ipfeed-collector/sources \ + -out-file /data/ipfeeds.parquet -no-upload ``` Full run with upload: ```sh go run ./cmd/ipfeed-collector \ - -sources-dir ./sources -out-dir /tmp \ + -sources-dir ./cmd/ipfeed-collector/sources -out-dir /tmp \ -s3-endpoint https://s3.example.com -s3-bucket ipfeeds \ -s3-prefix ipranges -s3-access-key "$KEY" -s3-secret-key-file /run/secrets/s3 ``` OTLP export is enabled automatically when `OTEL_EXPORTER_OTLP_ENDPOINT` is set; -otherwise the tool runs with no collector attached. +otherwise the tool runs with no collector attached. In daemon mode the same +instruments are also served in Prometheus format on `-http-addr` `/metrics` +(see below). ## Modes The tool runs in two modes: - **Single-shot** (default): performs one collection cycle — fetch, parse, - combine, write, upload — then exits. The process exit code is non-zero if - fewer than `-min-successful-sources` succeeded. Use this from cron or a - one-off invocation. + validate, annotate ASN, write, upload — then exits. The process exit code is + non-zero if fewer than `-min-successful-sources` succeeded. Use this from + cron or a one-off invocation. - **Daemon** (`-daemon`): runs one cycle immediately, then repeats every `-interval` (default `6h`) until it receives `SIGINT`/`SIGTERM`, at which point it stops after the in-flight cycle and exits 0. Cycles run - sequentially (never overlapping), and `sources/` is reloaded each cycle, so - feeds can be added or removed without a restart. A failed cycle is logged + sequentially (never overlapping), and the sources dir is re-read each cycle, + so feeds can be added or removed without a restart. A failed cycle is logged and the loop continues. ```sh # daemon, every 6h, health endpoints on :8080 go run ./cmd/ipfeed-collector -daemon -interval 6h -http-addr :8080 \ - -sources-dir ./sources -out-dir /var/lib/ipfeed -no-upload + -sources-dir ./cmd/ipfeed-collector/sources -out-dir /var/lib/ipfeed -no-upload ``` -### Health endpoints (daemon) +### Health and metrics endpoints (daemon) -When `-http-addr` is set, the daemon serves two endpoints: +When `-http-addr` is set, the daemon serves three endpoints on that one port: | path | meaning | |---|---| | `/healthz` | liveness — always `200 ok` once the server is listening | | `/readyz` | readiness — `200 ready` only after ≥1 successful cycle, else `503 not ready` | +| `/metrics` | Prometheus text format of every OTel instrument (below) | -`-interval` must be `> 0` in daemon mode; the tool errors at startup otherwise. +Metrics an operator will want on a dashboard (all also exported over OTLP): + +| Prometheus name | kind | meaning | +|---|---|---| +| `ipfeed_source_records{source,provider}` | gauge | valid prefix entries the source contributed in the latest cycle (0 when it failed) | +| `ipfeed_artifact_records` | gauge | prefix entries in the Parquet artifact just written — the lookup-table size | +| `ipfeed_artifact_size_bytes` | gauge | size of that artifact | +| `ipfeed_fetch_duration_seconds{source,provider}` | histogram | discover + download of one source | +| `ipfeed_parse_duration_seconds{source,provider}` | histogram | parse of one source's body | +| `ipfeed_write_duration_seconds` | histogram | sort + Parquet write (building the lookup artifact) | +| `ipfeed_upload_duration_seconds` | histogram | S3 PUT of the artifact | +| `ipfeed_cycle_duration_seconds{outcome}` | histogram | one whole cycle, fetch to upload | +| `ipfeed_cycles_total{outcome}` | counter | cycles by `success` / `failure` | +| `ipfeed_sources_succeeded` | gauge | sources OK in the latest cycle | +| `ipfeed_fetch_bytes_total`, `ipfeed_fetch_attempts_total`, `ipfeed_fetch_failures_total`, `ipfeed_records_valid_total`, `ipfeed_records_invalid_total`, `ipfeed_upload_bytes_total` | counter | per-source / per-upload running totals | + +A one-shot run has nowhere to be scraped from, so it reports the same +numbers (records, bytes, durations) in its end-of-run summary instead. + +`-interval` must be `> 0` in daemon mode; the tool errors at startup otherwise +(the reason is printed to stderr, exit code 2). `-healthcheck` is a self-probe mode: it issues a GET to `127.0.0.1/readyz` (defaulting the port to `8080`) and exits `0` if @@ -103,10 +142,11 @@ Run it in a separate process from the daemon, e.g. `ipfeed-collector -healthchec ## Configuration via environment -Every flag has an `IPFEED_*` environment-variable fallback. Precedence is: -**command-line flag > `IPFEED_*` env var > built-in default**. An invalid env -value (e.g. an unparseable duration) falls back to the built-in default rather -than failing, which keeps a bad env var from crash-looping the daemon. +Every flag except `-version` has an `IPFEED_*` environment-variable fallback. +Precedence is: **command-line flag > `IPFEED_*` env var > built-in default**. +An invalid env value (e.g. an unparseable duration or integer) falls back to the +built-in default rather than failing, which keeps a bad env var from +crash-looping the daemon. | flag | env var | |---|---| @@ -125,6 +165,7 @@ than failing, which keeps a bad env var from crash-looping the daemon. | `-interval` | `IPFEED_INTERVAL` | | `-http-addr` | `IPFEED_HTTP_ADDR` | | `-healthcheck` | `IPFEED_HEALTHCHECK` | +| `-version` | — (flag only) | | `-s3-endpoint` | `IPFEED_S3_ENDPOINT` | | `-s3-bucket` | `IPFEED_S3_BUCKET` | | `-s3-region` | `IPFEED_S3_REGION` (then `AWS_REGION`) | @@ -148,8 +189,8 @@ default**. | flag | default | purpose | |---|---|---| -| `-sources-dir` | `./sources` | directory of per-source YAML files | -| `-out-dir` | `$TMPDIR` | directory for the timestamped Parquet file (ignored when `-out-file` is set) | +| `-sources-dir` | `./sources` | directory of per-source YAML files (relative to the working directory) | +| `-out-dir` | `os.TempDir()` (`$TMPDIR` or `/tmp`) | directory for the timestamped Parquet file (ignored when `-out-file` is set) | | `-out-file` | — | exact local path for the Parquet file; overrides `-out-dir` and its timestamped name | | `-concurrency` | `8` | max concurrent source fetches | | `-timeout` | `30s` | per-request HTTP timeout | @@ -159,14 +200,38 @@ default**. | `-interval` | `6h` | daemon collection interval (must be `> 0` with `-daemon`) | | `-http-addr` | — | daemon health endpoint address, e.g. `:8080` (empty disables) | | `-healthcheck` | `false` | probe a running daemon's `/readyz` and exit 0/1 (container HEALTHCHECK) | +| `-version` | `false` | print `version=… commit=… date=…` (injected by the Nix build) and exit | | `-no-upload` | `false` | write Parquet locally only | -| `-s3-*` | — | endpoint, bucket, region, prefix, access key, secret (+ `-s3-secret-key-file`) | +| `-s3-*` | — | endpoint, bucket, region (`us-east-1`), prefix, access key, secret (+ `-s3-secret-key-file`) | | `-v` / `-debug` | `false` | debug logging | +## Output + +One Parquet file per cycle with the flat schema in `internal/ipfeed/model` +(`prefix`, `ip_version`, `asn`, `network_owner`, `service_operator`, +`provider`, `service`, `product`, `region`, `network_border_group`, +`direction`, `source_name`, `source_type`, `source_url`, `source_timestamp`, +`retrieved_at`, `confidence`). Rows are sorted by `prefix`, then +`source_name`. + +`asn` is a **representative** ASN for the prefix's `network_owner` / +`provider`, looked up in the curated table in `internal/ipfeed/asnmap` +(e.g. `aws` -> 16509, `cloudflare` -> 13335). It is *not* the per-prefix BGP +origin ASN — large providers announce from several ASNs — and is `0` when the +owner is not in the table. + +The xtcp2 daemon loads this file through `pkg/ipasn` (a longest-prefix-match +trie, atomically reloaded) to fill `enrich_socket_dest_asn` and +`enrich_socket_dest_network_owner`. The daemon-side flags +`-enrichAsn` / `-asnDbPath` / `-asnRefreshInterval` (env `ENRICH_ASN` / +`ASN_DB_PATH` / `ASN_REFRESH_INTERVAL`) are being added alongside this work; +see `docs/ipfeed-asn-enrichment.md`. + ## Adding / removing a source -Sources are one YAML file per feed under `sources/`. To add a feed, drop in a -new file; to remove one, delete it or set `enabled: false`. +Sources are one YAML file per feed under `cmd/ipfeed-collector/sources/`. To +add a feed, drop in a new file; to remove one, delete it or set +`enabled: false`. Source names must be unique across the directory. ```yaml name: my-feed @@ -183,5 +248,7 @@ enabled: true ``` If a feed uses a shape no existing parser handles, add a small parser in -`internal/parse/` and register it under a new key; otherwise a YAML file is all -that is needed. +`internal/ipfeed/parse/` and register it under a new key; otherwise a YAML file +is all that is needed. To give a new provider a representative ASN, add its +`network_owner` / `provider` spelling to the table in +`internal/ipfeed/asnmap/asnmap.go`. diff --git a/cmd/ipfeed-collector/main.go b/cmd/ipfeed-collector/main.go index 1227fe3..0623489 100644 --- a/cmd/ipfeed-collector/main.go +++ b/cmd/ipfeed-collector/main.go @@ -6,13 +6,15 @@ // // It runs in two modes: single-shot (the default — one collection cycle, then // exit) and daemon (-daemon — run immediately, then repeat every -interval, -// serving /healthz and /readyz when -http-addr is set). Every flag also reads +// serving /healthz, /readyz and Prometheus /metrics when -http-addr is set). +// Every flag also reads // an IPFEED_* environment variable when the flag is not given, so the daemon // is easy to configure from a systemd unit or container. package main import ( "context" + "errors" "flag" "fmt" "log/slog" @@ -124,7 +126,7 @@ func parseFlags(args []string) (flags, error) { fs.BoolVar(&f.daemon, "daemon", envBool("IPFEED_DAEMON", false), "run continuously, repeating every -interval") fs.DurationVar(&f.interval, "interval", envDur("IPFEED_INTERVAL", 6*time.Hour), "daemon collection interval") - fs.StringVar(&f.httpAddr, "http-addr", envStr("IPFEED_HTTP_ADDR", ""), "daemon health endpoint address, e.g. :8080 (empty disables)") + fs.StringVar(&f.httpAddr, "http-addr", envStr("IPFEED_HTTP_ADDR", ""), "daemon health (/healthz, /readyz) and Prometheus (/metrics) endpoint address, e.g. :8080 (empty disables)") fs.BoolVar(&f.healthcheck, "healthcheck", envBool("IPFEED_HEALTHCHECK", false), "probe a running daemon's /readyz and exit 0 (ready) or 1; used as the container HEALTHCHECK") fs.BoolVar(&f.version, "version", false, "print build version and exit") @@ -200,6 +202,13 @@ var ( func main() { f, err := parseFlags(os.Args[1:]) if err != nil { + if errors.Is(err, flag.ErrHelp) { + os.Exit(0) // -h/-help: usage was already printed by the FlagSet + } + // Surface the reason (e.g. "-interval must be > 0 in daemon mode") + // rather than exiting silently; flag-syntax errors are also echoed by + // the FlagSet, but the validation errors parseFlags adds are not. + fmt.Fprintln(os.Stderr, "ipfeed-collector: invalid flags:", err) os.Exit(2) } @@ -246,7 +255,11 @@ type sourceOutcome struct { } func run(rootCtx context.Context, f flags, log *slog.Logger) error { - tel, err := telemetry.Setup(rootCtx, "ipfeed-collector") + // Prometheus exposition only makes sense when there is an HTTP server to + // mount it on, i.e. daemon mode with -http-addr; a one-shot run reports its + // numbers in the end-of-run summary instead. + tel, err := telemetry.Setup(rootCtx, "ipfeed-collector", + telemetry.Options{Prometheus: f.daemon && f.httpAddr != ""}) if err != nil { return fmt.Errorf("telemetry: %w", err) } @@ -272,14 +285,18 @@ func run(rootCtx context.Context, f flags, log *slog.Logger) error { ctx, stop := signal.NotifyContext(rootCtx, os.Interrupt, syscall.SIGTERM) defer stop() - // One cycle, wrapped to record the cycle-outcome metric. Used by both modes. + // One cycle, wrapped to record the cycle-outcome and cycle-duration + // metrics. Used by both modes. collect := func(ctx context.Context) error { + start := time.Now() err := collectOnce(ctx, d) outcome := "success" if err != nil { outcome = "failure" } - tel.Cycles.Add(ctx, 1, metric.WithAttributes(attribute.String("outcome", outcome))) + attrs := metric.WithAttributes(attribute.String("outcome", outcome)) + tel.Cycles.Add(ctx, 1, attrs) + tel.CycleDuration.Record(ctx, time.Since(start).Seconds(), attrs) return err } @@ -291,10 +308,14 @@ func run(rootCtx context.Context, f flags, log *slog.Logger) error { var ready func() if f.httpAddr != "" { hs := health.NewServer(f.httpAddr) + if tel.PrometheusHandler != nil { + hs.Handle("/metrics", tel.PrometheusHandler) + } if err := hs.Start(ctx); err != nil { return fmt.Errorf("health server: %w", err) } - log.Info("health server listening", "addr", f.httpAddr) + log.Info("health server listening", "addr", f.httpAddr, + "metrics", tel.PrometheusHandler != nil) defer func() { //nolint:contextcheck // shutdown must not inherit the already-canceled daemon ctx // Fresh ctx: the daemon ctx is already canceled during shutdown. sctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) @@ -383,9 +404,15 @@ func collectOnce(ctx context.Context, d deps) error { // Aggregate. var sum summary.Summary var combined []model.Record - for _, o := range outcomes { + for i, o := range outcomes { sum.Add(o.result) combined = append(combined, o.valid...) + // Latest-cycle table size per source (0 for a failed source, so a feed + // that stops contributing is visible rather than frozen at its last value). + tel.SourceRecords.Record(ctx, int64(o.result.Valid), metric.WithAttributes( + attribute.String("source", sources[i].Name), + attribute.String("provider", sources[i].Provider), + )) } tel.SourcesSucceeded.Record(ctx, int64(sum.OKCount())) @@ -419,11 +446,18 @@ func collectOnce(ctx context.Context, d deps) error { outPath = f.outFile filename = filepath.Base(f.outFile) } + // Building the lookup artifact: the sort above plus the Parquet write. The + // duration is recorded even on failure so a slow-then-failing write shows up. + wstart := time.Now() size, err := output.WriteParquet(outPath, combined) + tel.WriteDuration.Record(ctx, time.Since(wstart).Seconds()) if err != nil { return fmt.Errorf("write parquet: %w", err) } - log.Info("wrote parquet", "path", outPath, "records", len(combined), "bytes", size) + tel.ArtifactRecords.Record(ctx, int64(len(combined))) + tel.ArtifactBytes.Record(ctx, size) + log.Info("wrote parquet", "path", outPath, "records", len(combined), "bytes", size, + "duration", time.Since(wstart)) uploadURL := "" if !f.noUpload { @@ -477,8 +511,10 @@ func processSource(ctx context.Context, client *fetch.Client, tel *telemetry.Tel parser, ok := parse.Get(src.Parser) if !ok { // validated at load, but guard anyway - res.Note = "unknown parser " + src.Parser + err := fmt.Errorf("unknown parser %q", src.Parser) + res.Note = "parse: " + err.Error() res.Duration = time.Since(start) + log.Error("parse failed", "source", src.Name, "parser", src.Parser, "err", err) return sourceOutcome{result: res} } retrievedAt := time.Now().UTC().Format(time.RFC3339) @@ -486,9 +522,12 @@ func processSource(ctx context.Context, client *fetch.Client, tel *telemetry.Tel records, err := parser.Parse(fr.Body, src.Meta(), retrievedAt) tel.ParseDuration.Record(ctx, time.Since(pstart).Seconds(), attrs) if err != nil { + // The source counts as failed (res.OK stays false) and the reason is + // both logged here and carried into the end-of-run summary via Note. res.Note = "parse: " + err.Error() res.Duration = time.Since(start) - log.Error("parse failed", "source", src.Name, "err", err) + log.Error("parse failed", "source", src.Name, "parser", src.Parser, + "bytes", res.FetchedBytes, "err", err) return sourceOutcome{result: res} } res.Parsed = len(records) @@ -540,11 +579,13 @@ func uploadResult(ctx context.Context, f flags, tel *telemetry.Telemetry, log *s ctx, span := tel.Tracer.Start(ctx, "upload", trace.WithAttributes(attribute.String("key", key))) defer span.End() + ustart := time.Now() url, err := up.Put(ctx, key, file, size) + tel.UploadDuration.Record(ctx, time.Since(ustart).Seconds()) if err != nil { return "", err } tel.UploadBytes.Add(ctx, size) - log.Info("uploaded", "url", url, "bytes", size) + log.Info("uploaded", "url", url, "bytes", size, "duration", time.Since(ustart)) return url, nil } diff --git a/cmd/ipfeed-collector/main_test.go b/cmd/ipfeed-collector/main_test.go index 042c926..96dc984 100644 --- a/cmd/ipfeed-collector/main_test.go +++ b/cmd/ipfeed-collector/main_test.go @@ -2,14 +2,15 @@ package main import ( "context" + "log/slog" + "math" "net/http" "net/http/httptest" "os" + "strconv" "sync/atomic" "testing" "time" - - "log/slog" ) // setOrUnset sets key to val when set is true, otherwise ensures it is unset, @@ -83,15 +84,77 @@ func TestEnvHelpers(t *testing.T) { } }) + t.Run("int", func(t *testing.T) { + tests := []struct { + description string + val string // env value (ignored when set is false) + set bool + def int + expected int + }{ + // positive + {description: "positive: a valid positive integer parses", val: "42", set: true, def: 8, expected: 42}, + {description: "positive: a negative integer parses (validation is the caller's job)", val: "-3", set: true, def: 8, expected: -3}, + {description: "positive: an explicit leading plus sign parses", val: "+7", set: true, def: 8, expected: 7}, + // negative + {description: "negative: a non-numeric value falls back to the default", val: "eight", set: true, def: 8, expected: 8}, + {description: "negative: a float falls back to the default (Atoi is integer-only)", val: "1.5", set: true, def: 8, expected: 8}, + {description: "negative: an empty value falls back to the default", val: "", set: true, def: 8, expected: 8}, + // boundary + {description: "boundary: unset uses the default", set: false, def: 8, expected: 8}, + {description: "boundary: zero parses as zero, not the default", val: "0", set: true, def: 8, expected: 0}, + {description: "boundary: max int parses", val: strconv.Itoa(math.MaxInt), set: true, def: 8, expected: math.MaxInt}, + {description: "boundary: min int parses", val: strconv.Itoa(math.MinInt), set: true, def: 8, expected: math.MinInt}, + // corner + {description: "corner: surrounding whitespace is not trimmed and falls back to the default", val: " 42 ", set: true, def: 8, expected: 8}, + {description: "corner: a value overflowing int falls back to the default", val: "99999999999999999999999", set: true, def: 8, expected: 8}, + {description: "corner: hex is not accepted and falls back to the default", val: "0x10", set: true, def: 8, expected: 8}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + const key = "IPFEED_TEST_INT" + setOrUnset(t, key, tc.val, tc.set) + if got := envInt(key, tc.def); got != tc.expected { + t.Errorf("envInt(%q=%q, def=%d) = %d, want %d", key, tc.val, tc.def, got, tc.expected) + } + }) + } + }) + t.Run("bool", func(t *testing.T) { - const key = "IPFEED_TEST_BOOL" - t.Setenv(key, "true") - if !envBool(key, false) { - t.Error("positive: 'true' should parse to true") + tests := []struct { + description string + val string // env value (ignored when set is false) + set bool + def bool + expected bool + }{ + // positive + {description: "positive: 'true' parses to true", val: "true", set: true, def: false, expected: true}, + {description: "positive: 'false' parses to false over a true default", val: "false", set: true, def: true, expected: false}, + {description: "positive: '1' parses to true", val: "1", set: true, def: false, expected: true}, + {description: "positive: '0' parses to false", val: "0", set: true, def: true, expected: false}, + {description: "positive: 'TRUE' (upper case) parses to true", val: "TRUE", set: true, def: false, expected: true}, + {description: "positive: 't' short form parses to true", val: "t", set: true, def: false, expected: true}, + // negative + {description: "negative: a non-bool value falls back to the default (false)", val: "notabool", set: true, def: false, expected: false}, + {description: "negative: a non-bool value falls back to the default (true)", val: "notabool", set: true, def: true, expected: true}, + {description: "negative: 'yes' is not a Go bool and falls back to the default", val: "yes", set: true, def: false, expected: false}, + // boundary + {description: "boundary: unset uses the default (false)", set: false, def: false, expected: false}, + {description: "boundary: unset uses the default (true)", set: false, def: true, expected: true}, + // corner + {description: "corner: an explicitly empty value falls back to the default", val: "", set: true, def: true, expected: true}, + {description: "corner: whitespace around the value is not trimmed and falls back to the default", val: " true", set: true, def: false, expected: false}, } - t.Setenv(key, "notabool") - if envBool(key, false) { - t.Error("negative: invalid bool should fall back to default (false)") + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + const key = "IPFEED_TEST_BOOL" + setOrUnset(t, key, tc.val, tc.set) + if got := envBool(key, tc.def); got != tc.expected { + t.Errorf("envBool(%q=%q, def=%v) = %v, want %v", key, tc.val, tc.def, got, tc.expected) + } + }) } }) } diff --git a/cmd/xtcp2/xtcp2.go b/cmd/xtcp2/xtcp2.go index 7ae92e2..7c33e2c 100644 --- a/cmd/xtcp2/xtcp2.go +++ b/cmd/xtcp2/xtcp2.go @@ -186,6 +186,21 @@ const ( // selection; empty = auto-detect from the default routes. uplinkInterfacesCst = "" populateNsidCst = false + enrichLocalityCst = false + // localityRefreshIntervalCst throttles the full per-namespace rtnetlink + // re-discovery: every namespace is re-dumped at most this often on the + // reconcile path so interface/route changes are picked up within a minute. + // New namespaces are dumped on the next reconcile regardless, and failed or + // loopback-only namespaces retry on their own 30s-5m backoff. 0 = discover + // each namespace once and never refresh (static topologies only). + localityRefreshIntervalCst = 60 * time.Second + // ASN enrichment is off by default and the artifact path has no sensible + // default. asnRefreshIntervalCst re-stats the artifact hourly and reloads it + // only when its size/mtime changed, so a refreshed — or late-arriving — + // ipfeed-collector file is picked up without a restart. 0 = load once. + enrichAsnCst = false + asnDbPathCst = "" + asnRefreshIntervalCst = 1 * time.Hour ipv4TtlCst uint = 0 ipv6HopLimitCst uint = 0 @@ -284,6 +299,13 @@ type mainFlags struct { uplinkInterfaces *string populateNsid *bool + enrichAsn *bool + asnDbPath *string + asnRefreshInterval *time.Duration + + enrichLocality *bool + localityRefreshInterval *time.Duration + ipv4Ttl *uint ipv6HopLimit *uint grpcPort *uint @@ -424,6 +446,11 @@ func defineEnrichmentFlags(f *mainFlags) { f.uplinkCount = flag.Uint("uplinkCount", uplinkCountCst, "number of uplink slots to populate for LLDP/NIC enrichment (hosts are typically dual-homed = 2; max 2). Falls back to UPLINK_COUNT env.") f.uplinkInterfaces = flag.String("uplinkInterfaces", uplinkInterfacesCst, "comma-separated explicit uplink interface names (e.g. \"eth0,eth1\") overriding default-route auto-detection for -enrichLldp/-enrichNic. Falls back to UPLINK_INTERFACES env.") f.populateNsid = flag.Bool("populateNsid", populateNsidCst, "best-effort: query each namespace's NETNSA_NSID via rtnetlink into the nsid column (usually 0/unassigned for docker/containerd; netns_inode is the stable key). Falls back to POPULATE_NSID env.") + f.enrichAsn = flag.Bool("enrichAsn", enrichAsnCst, "best-effort: longest-prefix-match each socket's destination against the ipfeed-collector Parquet artifact (-asnDbPath) and stamp enrich_socket_dest_asn / enrich_socket_dest_network_owner. Self and local-subnet destinations (see -enrichLocality) skip the lookup. Non-fatal when the artifact is missing. Falls back to ENRICH_ASN env.") + f.asnDbPath = flag.String("asnDbPath", asnDbPathCst, "path to the ipfeed-collector Parquet artifact (prefix -> asn, network_owner) used by -enrichAsn. Falls back to ASN_DB_PATH env.") + f.asnRefreshInterval = flag.Duration("asnRefreshInterval", asnRefreshIntervalCst, "how often -enrichAsn re-stats -asnDbPath and reloads it when its size/mtime changed (also how often a missing artifact is retried); 0 = load once at startup, never reload. Falls back to ASN_REFRESH_INTERVAL env.") + f.enrichLocality = flag.Bool("enrichLocality", enrichLocalityCst, "best-effort: per namespace, dump the local addresses + routing table via rtnetlink and classify each socket's destination as self/local-subnet/remote, stamping the enrich_socket_dest_locality + interface-name columns (bound idiag_if and route egress). Non-fatal on read failure. Falls back to ENRICH_LOCALITY env.") + f.localityRefreshInterval = flag.Duration("localityRefreshInterval", localityRefreshIntervalCst, "how often -enrichLocality re-dumps every namespace's addresses/routes on the reconcile path (new namespaces are always dumped on the next reconcile; failed or loopback-only namespaces retry on a 30s-5m backoff); 0 = discover each namespace once, never refresh. Falls back to LOCALITY_REFRESH_INTERVAL env.") } func printFlags(f *mainFlags) { @@ -481,6 +508,11 @@ func printFlags(f *mainFlags) { fmt.Println("*uplinkCount:", *f.uplinkCount) fmt.Println("*uplinkInterfaces:", *f.uplinkInterfaces) fmt.Println("*populateNsid:", *f.populateNsid) + fmt.Println("*enrichAsn:", *f.enrichAsn) + fmt.Println("*asnDbPath:", *f.asnDbPath) + fmt.Println("*asnRefreshInterval:", *f.asnRefreshInterval) + fmt.Println("*enrichLocality:", *f.enrichLocality) + fmt.Println("*localityRefreshInterval:", *f.localityRefreshInterval) fmt.Println("*d:", *f.d) } @@ -535,21 +567,26 @@ func buildConfig(f *mainFlags, des *xtcp_config.EnabledDeserializers) *xtcp_conf Location: *f.location, Hostname: *f.hostname, // DaemonVersion: build provenance (-ldflags) stamped on every record. - DaemonVersion: versionString(), - ResolveContainerId: *f.resolveContainerId, - EnrichContainerEnable: *f.enrichContainer, - DockerSocketPath: *f.dockerSocket, - EnrichLldpEnable: *f.enrichLldp, - LldpdSocketPath: *f.lldpdSocket, - LldpdVersionHint: *f.lldpdVersionHint, - EnrichNicEnable: *f.enrichNic, - UplinkCount: uint32(*f.uplinkCount), - UplinkInterfaces: splitCSV(*f.uplinkInterfaces), - PopulateNsid: *f.populateNsid, - Ipv4Ttl: uint32(*f.ipv4Ttl), - Ipv6HopLimit: uint32(*f.ipv6HopLimit), - GrpcPort: uint32(*f.grpcPort), - EnabledDeserializers: des, + DaemonVersion: versionString(), + ResolveContainerId: *f.resolveContainerId, + EnrichContainerEnable: *f.enrichContainer, + DockerSocketPath: *f.dockerSocket, + EnrichLldpEnable: *f.enrichLldp, + LldpdSocketPath: *f.lldpdSocket, + LldpdVersionHint: *f.lldpdVersionHint, + EnrichNicEnable: *f.enrichNic, + UplinkCount: uint32(*f.uplinkCount), + UplinkInterfaces: splitCSV(*f.uplinkInterfaces), + PopulateNsid: *f.populateNsid, + EnrichAsnEnable: *f.enrichAsn, + AsnDbPath: *f.asnDbPath, + AsnRefreshInterval: durationpb.New(*f.asnRefreshInterval), + EnrichLocalityEnable: *f.enrichLocality, + LocalityRefreshInterval: durationpb.New(*f.localityRefreshInterval), + Ipv4Ttl: uint32(*f.ipv4Ttl), + Ipv6HopLimit: uint32(*f.ipv6HopLimit), + GrpcPort: uint32(*f.grpcPort), + EnabledDeserializers: des, IoUring: *f.ioUring, IoUringRecvBatchSize: uint32(*f.ioUringRecvBatch), @@ -1449,6 +1486,26 @@ func envOverrideLabeling(c *xtcp_config.XtcpConfig, debugLevel uint) { c.EnrichNicEnable = v logEnv("ENRICH_NIC", fmt.Sprintf("c.EnrichNicEnable:%t", v), debugLevel) } + if v, ok := envBool("ENRICH_ASN"); ok { + c.EnrichAsnEnable = v + logEnv("ENRICH_ASN", fmt.Sprintf("c.EnrichAsnEnable:%t", v), debugLevel) + } + if v, ok := envString("ASN_DB_PATH"); ok { + c.AsnDbPath = v + logEnv("ASN_DB_PATH", fmt.Sprintf("c.AsnDbPath:%s", v), debugLevel) + } + if d, ok := envDuration("ASN_REFRESH_INTERVAL"); ok { + c.AsnRefreshInterval = durationpb.New(d) + logEnv("ASN_REFRESH_INTERVAL", fmt.Sprintf("c.AsnRefreshInterval:%s", c.AsnRefreshInterval.String()), debugLevel) + } + if v, ok := envBool("ENRICH_LOCALITY"); ok { + c.EnrichLocalityEnable = v + logEnv("ENRICH_LOCALITY", fmt.Sprintf("c.EnrichLocalityEnable:%t", v), debugLevel) + } + if d, ok := envDuration("LOCALITY_REFRESH_INTERVAL"); ok { + c.LocalityRefreshInterval = durationpb.New(d) + logEnv("LOCALITY_REFRESH_INTERVAL", fmt.Sprintf("c.LocalityRefreshInterval:%s", c.LocalityRefreshInterval.String()), debugLevel) + } if v, ok := envUint32("UPLINK_COUNT"); ok { c.UplinkCount = v logEnv("UPLINK_COUNT", fmt.Sprintf("c.UplinkCount:%d", v), debugLevel) @@ -1530,6 +1587,11 @@ func printConfig(c *xtcp_config.XtcpConfig, comment string) { fmt.Println("c.UplinkCount:", c.UplinkCount) fmt.Println("c.UplinkInterfaces:", c.UplinkInterfaces) fmt.Println("c.PopulateNsid:", c.PopulateNsid) + fmt.Println("c.EnrichAsnEnable:", c.EnrichAsnEnable) + fmt.Println("c.AsnDbPath:", c.AsnDbPath) + fmt.Println("c.AsnRefreshInterval:", c.AsnRefreshInterval) + fmt.Println("c.EnrichLocalityEnable:", c.EnrichLocalityEnable) + fmt.Println("c.LocalityRefreshInterval:", c.LocalityRefreshInterval) fmt.Println("c.GrpcPort:", c.GrpcPort) fmt.Println("c.EnabledDeserializers:", c.EnabledDeserializers) } diff --git a/cmd/xtcp2/xtcp2_test.go b/cmd/xtcp2/xtcp2_test.go index 0851567..41670a6 100644 --- a/cmd/xtcp2/xtcp2_test.go +++ b/cmd/xtcp2/xtcp2_test.go @@ -810,6 +810,20 @@ func TestPrintFlags(t *testing.T) { f.ioUring = &b f.ioUringRecvBatch = &n f.ioUringCqeBatch = &n + f.enrichContainer = &b + f.dockerSocket = &s + f.enrichLldp = &b + f.lldpdSocket = &s + f.lldpdVersionHint = &s + f.enrichNic = &b + f.uplinkCount = &n + f.uplinkInterfaces = &s + f.populateNsid = &b + f.enrichAsn = &b + f.asnDbPath = &s + f.asnRefreshInterval = &d + f.enrichLocality = &b + f.localityRefreshInterval = &d // Redirect stdout so the call doesn't litter test output. r, w, _ := os.Pipe() orig := os.Stdout @@ -915,6 +929,12 @@ func TestBuildConfig(t *testing.T) { deserializers: &ds, promListen: &pl, promPath: &pp, goMaxProcs: &gmp, profileMode: &pm, v: &v, conf: &conf, d: &d, ioUring: &iu, ioUringRecvBatch: &iurb, ioUringCqeBatch: &iucb, + enrichContainer: &iu, dockerSocket: &mar, + enrichLldp: &iu, lldpdSocket: &mar, lldpdVersionHint: &mar, + enrichNic: &iu, uplinkCount: &wf, uplinkInterfaces: &mar, + populateNsid: &iu, + enrichAsn: &iu, asnDbPath: &mar, asnRefreshInterval: &rf, + enrichLocality: &iu, localityRefreshInterval: &rf, } des := getDeserializers(*f.deserializers) c := buildConfig(f, des) @@ -1147,3 +1167,70 @@ func TestDefaultDestFor(t *testing.T) { }) } } + +// TestEnvOverrideEnrichmentAsnLocality covers the ASN + locality environment +// overrides handled by envOverrideLabeling: valid values are applied, unset and +// unparseable values leave the config untouched. +func TestEnvOverrideEnrichmentAsnLocality(t *testing.T) { + tests := []struct { + description string + env map[string]string + want func(c *xtcp_config.XtcpConfig) bool + }{ + // positive + {"ENRICH_ASN=true enables ASN enrichment", map[string]string{"ENRICH_ASN": "true"}, + func(c *xtcp_config.XtcpConfig) bool { return c.EnrichAsnEnable }}, + {"ASN_DB_PATH sets the artifact path verbatim", map[string]string{"ASN_DB_PATH": "/var/lib/xtcp/feeds.parquet"}, + func(c *xtcp_config.XtcpConfig) bool { return c.AsnDbPath == "/var/lib/xtcp/feeds.parquet" }}, + {"ASN_REFRESH_INTERVAL=30m parses as a duration", map[string]string{"ASN_REFRESH_INTERVAL": "30m"}, + func(c *xtcp_config.XtcpConfig) bool { return c.AsnRefreshInterval.AsDuration() == 30*time.Minute }}, + {"ENRICH_LOCALITY=1 enables locality enrichment", map[string]string{"ENRICH_LOCALITY": "1"}, + func(c *xtcp_config.XtcpConfig) bool { return c.EnrichLocalityEnable }}, + {"LOCALITY_REFRESH_INTERVAL=90s parses as a duration", map[string]string{"LOCALITY_REFRESH_INTERVAL": "90s"}, + func(c *xtcp_config.XtcpConfig) bool { return c.LocalityRefreshInterval.AsDuration() == 90*time.Second }}, + {"all five together", map[string]string{ + "ENRICH_ASN": "true", "ASN_DB_PATH": "/f.parquet", "ASN_REFRESH_INTERVAL": "1h", + "ENRICH_LOCALITY": "true", "LOCALITY_REFRESH_INTERVAL": "2m"}, + func(c *xtcp_config.XtcpConfig) bool { + return c.EnrichAsnEnable && c.AsnDbPath == "/f.parquet" && c.AsnRefreshInterval.AsDuration() == time.Hour && + c.EnrichLocalityEnable && c.LocalityRefreshInterval.AsDuration() == 2*time.Minute + }}, + // negative — unset leaves zero values + {"nothing set -> all zero", map[string]string{}, + func(c *xtcp_config.XtcpConfig) bool { + return !c.EnrichAsnEnable && c.AsnDbPath == "" && c.AsnRefreshInterval == nil && + !c.EnrichLocalityEnable && c.LocalityRefreshInterval == nil + }}, + {"ENRICH_ASN=maybe (unparseable bool) is ignored", map[string]string{"ENRICH_ASN": "maybe"}, + func(c *xtcp_config.XtcpConfig) bool { return !c.EnrichAsnEnable }}, + {"ASN_REFRESH_INTERVAL=soon (unparseable duration) is ignored", map[string]string{"ASN_REFRESH_INTERVAL": "soon"}, + func(c *xtcp_config.XtcpConfig) bool { return c.AsnRefreshInterval == nil }}, + // boundary + {"ENRICH_ASN=false explicitly false", map[string]string{"ENRICH_ASN": "false"}, + func(c *xtcp_config.XtcpConfig) bool { return !c.EnrichAsnEnable }}, + {"ASN_REFRESH_INTERVAL=0 -> zero duration set (load once)", map[string]string{"ASN_REFRESH_INTERVAL": "0"}, + func(c *xtcp_config.XtcpConfig) bool { + return c.AsnRefreshInterval != nil && c.AsnRefreshInterval.AsDuration() == 0 + }}, + // corner + {"ASN_DB_PATH set to empty string is applied as empty", map[string]string{"ASN_DB_PATH": ""}, + func(c *xtcp_config.XtcpConfig) bool { return c.AsnDbPath == "" }}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + for _, k := range []string{"ENRICH_ASN", "ASN_DB_PATH", "ASN_REFRESH_INTERVAL", "ENRICH_LOCALITY", "LOCALITY_REFRESH_INTERVAL"} { + if v, ok := tc.env[k]; ok { + t.Setenv(k, v) + } else { + t.Setenv(k, "") + os.Unsetenv(k) //nolint:errcheck,usetesting // t.Setenv registered the restore; Unsetenv makes "absent" observable + } + } + c := &xtcp_config.XtcpConfig{} + envOverrideLabeling(c, 0) + if !tc.want(c) { + t.Errorf("config after env override does not match expectation: %+v", c) + } + }) + } +} diff --git a/cmd/xtcp2client/xtcp2client_test.go b/cmd/xtcp2client/xtcp2client_test.go index c115258..a06ace1 100644 --- a/cmd/xtcp2client/xtcp2client_test.go +++ b/cmd/xtcp2client/xtcp2client_test.go @@ -49,7 +49,7 @@ func sampleClientRecord() *xtcp_flat_record.XtcpFlatRecord { InetDiagMsgFamily: 2, InetDiagMsgSocketSource: []byte{10, 0, 0, 5}, InetDiagMsgState: 10, // LISTEN - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, } } diff --git a/docs/design-metadata-enrichment.md b/docs/design-metadata-enrichment.md index 69065f6..36fcc9e 100644 --- a/docs/design-metadata-enrichment.md +++ b/docs/design-metadata-enrichment.md @@ -79,6 +79,11 @@ Precedence: **defaults < flags < env < `XTCP_CONFIG_JSON`** (`cmd/xtcp2/xtcp2.go | `-uplinkCount` | `UPLINK_COUNT` | `uplink_count` | 2 | | `-uplinkInterfaces` | `UPLINK_INTERFACES` (CSV) | `uplink_interfaces` | auto (default routes) | | `-populateNsid` | `POPULATE_NSID` | `populate_nsid` | false | +| `-enrichAsn` | `ENRICH_ASN` | `enrich_asn_enable` | false | +| `-asnDbPath` | `ASN_DB_PATH` | `asn_db_path` | "" (required when enabled) | +| `-asnRefreshInterval` | `ASN_REFRESH_INTERVAL` | `asn_refresh_interval` | 1h (0 = load once; a missing artifact is retried on this cadence) | +| `-enrichLocality` | `ENRICH_LOCALITY` | `enrich_locality_enable` | false | +| `-localityRefreshInterval` | `LOCALITY_REFRESH_INTERVAL` | `locality_refresh_interval` | 60s | ## 4. ClickHouse diff --git a/docs/integration-testing.md b/docs/integration-testing.md index b0cbc92..f1ead0a 100644 --- a/docs/integration-testing.md +++ b/docs/integration-testing.md @@ -187,6 +187,7 @@ Two exposure shapes: | `microvm-x86_64-lifecycle-nats` | `nats` | runner | 1024 | Native in-VM NATS server + subscriber; `NATS_CONSUME` counts consumed records. | | `microvm-x86_64-lifecycle-nsq` | `nsq` | runner | 1024 | Native in-VM nsqd + an `nsq_tail` consumer; `NSQ_CONSUME` reads nsqd's per-channel `finish_count`. | | `microvm-x86_64-lifecycle-{tcp,udp,unix,unixgram}-sink` | `{tcp,udp,unix,unixgram}-sink` | runner | 1024 | Raw-socket dest → an in-VM `ncat`/`socat` receiver; `RAW_SOCKET` validates the records arrived + the per-scheme `Writes` counter grew. Four flavors sharing one `mkLifecycleSocketSink` factory. | +| `test-microvm-lifecycle-x86_64-interface-naming` (package; `nix run .#test-microvm-lifecycle-x86_64-interface-naming`) | `interface-naming` | runner | 1024 | Docker-free **enrichment-content** flavor: two veth pairs + a peer netns, `tcp_client` bound with `SO_BINDTODEVICE` and unbound-via-route, xtcp2 `-enrichLocality -enrichAsn`. `IFNAME` asserts the bound (`idiag_if`-derived) and route-egress interface names on distinguishable records. `ASN` runs the **real `ipfeed-collector`** against a loopback-served synthetic `goog.json` (8.8.8.0/24 → AS15169/google, real gstatic format, no internet needed for the feed), ordered *after* xtcp2 so the daemon picks the artifact up on its `-asnRefreshInterval` tick, and asserts the record for a held TCP connection to `8.8.8.8:53` carries `enrich_socket_dest_asn=15169`, `network_owner=google`, `LOCALITY_REMOTE`. 600 s timeout. | | `microvm-x86_64-s3parquet-pipeline` | `s3parquet` | raw boot | 6144 | The s3parquet lifecycle VM (in-VM MinIO, xtcp2 writes Parquet), booted directly. | | `microvm-x86_64-soak` | `soak` | runner | 3072 | xtcp2 (`-dest null`) + nsTest churn + tcp_server/client + /metrics scraper. Long stability (1h default, `--duration 24h`); asserts no panic/restart, ≥10 churn events, bounded RSS/threads. | | `microvm-x86_64-tcp-stress` | `tcp-stress` | runner | 3072 | dockerd + 20 containers × 250 sockets, each its own netns. Asserts Method B discovered ≥ container-count namespaces, 0 panics. | diff --git a/docs/ipfeed-asn-enrichment.md b/docs/ipfeed-asn-enrichment.md index b3620b5..c36f2e4 100644 --- a/docs/ipfeed-asn-enrichment.md +++ b/docs/ipfeed-asn-enrichment.md @@ -8,22 +8,20 @@ schema, and writes a combined Parquet artifact (optionally to S3). Each row is essentially `prefix → {network_owner, provider, service, region, …}`. xtcp2 builds one `XtcpFlatRecord` per TCP socket on a hot path. Two of its -fields were reserved but never populated: +fields had been reserved since the beginning but never populated +(`inet_diag_msg_socket_dest_asn` 1011 and `..._next_hop_asn` 1012, in the raw +kernel payload block). This work populates the **destination** side per socket, +from the feed data we already parse. The fields now live in the daemon-computed +300s enrichment block (record epoch 2; the 10xx tags/names are `reserved`): -- `inet_diag_msg_socket_dest_asn` (1011) -- `inet_diag_msg_socket_next_hop_asn` (1012) +- **`enrich_socket_dest_asn` (320)** — a *representative* ASN derived from the + destination's network owner via a small curated `provider → ASN` map + (`internal/ipfeed/asnmap`). +- **`enrich_socket_dest_network_owner` (322)** — the feed's `network_owner` + string verbatim (e.g. `cloudflare`, `aws`). No ASN indirection, so it is exact + for any prefix the feeds cover. -This work populates the **destination** side per socket, from the feed data we -already parse: - -- **`inet_diag_msg_socket_dest_asn` (1011)** — a *representative* ASN derived - from the destination's network owner via a small curated `provider → ASN` - map (`internal/ipfeed/asnmap`). -- **`inet_diag_msg_socket_dest_network_owner` (1018, new)** — the feed's - `network_owner` string verbatim (e.g. `cloudflare`, `aws`). No ASN - indirection, so it is exact for any prefix the feeds cover. - -`next_hop_asn` (1012) stays 0 — see *Phasing*. +`enrich_socket_dest_next_hop_asn` (321) stays 0 — see *Phasing*. ### Data reality and the representative-ASN caveat @@ -73,14 +71,40 @@ enrichers: `bart.Table[Attr]` behind an `atomic.Pointer`; `Lookup(netip.Addr) (Attr, bool)` is a pure longest-prefix read; `Reload(path)` rebuilds and swaps the pointer, so a refresh never blocks readers and a *failed* reload leaves the in-service - table intact. + table intact. `ReloadIfChanged(path)` first stats the file and skips the + rebuild when size and mtime are unchanged. The loader refuses an artifact + that yields **no usable prefix** (`ErrNoPrefixes`: zero rows, or every prefix + unparseable) instead of silently installing an all-miss table, and a Parquet + read error is never mistaken for end-of-file. The zero `Index` is usable + (misses until the first successful load). +- **Producer write is atomic** — `output.WriteParquet` writes `.tmp`, + fsyncs, then renames over ``, so a consumer reloading on a timer never + opens a half-written artifact. ### Hot-path wiring (`pkg/xtcp`) -- `initAsnEnricher` (`enrich.go`) loads `asn_db_path` once at startup, gated by - `enrich_asn_enable`. If `asn_refresh_interval > 0`, a background goroutine - reloads on that cadence (bound to the daemon context). Every failure is - best-effort: log + Prometheus counter, columns left empty, never fatal. +- `initAsnEnricher` (`enrich.go`) loads `asn_db_path` at startup, gated by + `enrich_asn_enable`. If `asn_refresh_interval > 0` (daemon default **1h**), a + background goroutine calls `ReloadIfChanged` on that cadence (bound to the + daemon context): an unchanged file is not rebuilt, a changed one is swapped + in, and a **missing or bad artifact at startup is retried on every tick** — + the empty index is installed so a late-arriving file is picked up without a + restart. With the interval at 0 a failed first load leaves enrichment + disabled. Every failure is best-effort: log + Prometheus counter + (`refreshAsn/reload/{ok,unchanged,error}`), columns left empty, never fatal. +- Metrics for the lookup table itself (`function="loadAsn"`, same + `xtcp_gauges` / `xtcp_histograms` families as the rest of the daemon): gauges + `prefixes` (entries in the trie in service), `artifactBytes` (size of the + Parquet file it was built from) and `loadedAt` (Unix seconds of the last + successful load); summaries `build` `duration` (read the artifact + build the + trie, one sample per successful load) and `error` `duration` (time spent in a + failed load attempt). A failed or skipped reload never moves the gauges, so + they always describe the table lookups are answered from. The collector side + (download and artifact-build timings, per-source and total entry counts) is + exposed by `ipfeed-collector -daemon -http-addr` on `/metrics`; see + `cmd/ipfeed-collector/DESIGN.md` § Telemetry. +- CLI flags `-enrichAsn` / `-asnDbPath` / `-asnRefreshInterval`; environment + `ENRICH_ASN` / `ASN_DB_PATH` / `ASN_REFRESH_INTERVAL`. - `applyEnrichment` converts the record's 16-byte destination (`inet_diag_msg_socket_destination`, a kernel `__be32[4]` slot) to a `netip.Addr` **alloc-free**, keyed on `inet_diag_msg_family` (IPv4 lives in the @@ -90,9 +114,9 @@ enrichers: ### Configuration (`proto/xtcp_config/v1`) -- `enrich_asn_enable` (bool, 239) -- `asn_db_path` (string, 240) -- `asn_refresh_interval` (Duration, 241; 0 = load once, never reload) +- `enrich_asn_enable` (bool, 240) +- `asn_db_path` (string, 241) +- `asn_refresh_interval` (Duration, 242; daemon default 1h; 0 = load once, never reload or retry) ## Artifact format @@ -100,18 +124,48 @@ Phase 1 reuses the collector's existing **Parquet** artifact — `pkg/ipasn` rea only the `prefix`, `asn`, and `network_owner` columns. MMDB is noted above as a possible future distribution format. +## End-to-end check (microVM) + +The `interface-naming` lifecycle flavor +(`nix run .#test-microvm-lifecycle-x86_64-interface-naming`, see +`docs/integration-testing.md`) proves the whole chain on a real kernel without +depending on the internet for the *feed*: + +1. `xtcp2-asn-feed` serves a synthetic `goog.json` (real gstatic format; only + Google's public-DNS ranges 8.8.8.0/24, 8.8.4.0/24, 2001:4860:4860::/48) on + `127.0.0.1:8099`. +2. `xtcp2-asn-collector` runs the real `ipfeed-collector` (`-sources-dir` with a + `gcp-goog.yaml` pointed at that URL, `-no-upload`, `-out-file + /run/xtcp2-asn/asn.parquet`) — fetch → parse → asnmap (`gcp` → AS15169) → + atomic Parquet write. It is ordered **after** `xtcp2.service` so the artifact + is late and the daemon's `-asnRefreshInterval 5s` retry path installs it. +3. `xtcp2-asn-dialer` holds a TCP connection to `8.8.8.8:53` (re-dialing every + ~15 s), so the daemon sees a `LOCALITY_REMOTE` socket inside 8.8.8.0/24 + (ESTABLISHED, or SYN_SENT if the host is offline — either is enriched). +4. Self-test check 5g polls the daemon's jsonl for a record whose + `inet_diag_msg_socket_destination` is 8.8.8.8, `..._destination_port` is 53, + `enrich_socket_dest_asn == "15169"` (uint64 → JSON string), network owner + `google`, locality `LOCALITY_REMOTE`, **and** that the daemon's + `xtcp_gauges{function="loadAsn",variable="prefixes"}` equals the number of + prefixes in the fixture (3), then prints `XTCP2_SELF_TEST_ASN_{PASS,FAIL}` + plus the daemon's `loadAsn` / `refreshAsn` metric lines. + +Note the address bytes: the daemon copies the kernel's raw `__be32[4]` for every +family, so a v4 destination is 16 bytes (4 octets + 12 zero bytes), base64 +`CAgICAAAAAAAAAAAAAAAAA==` for 8.8.8.8. + ## Phasing - **Phase 1 (this work).** `provider → ASN` map over the existing feeds fills `dest_asn` (representative) and `dest_network_owner` (exact). In-proc `bart` trie; on-agent; opt-in. - **Phase 2 (future).** Ingest a BGP RIB (MRT) so we can attach the *real* - per-prefix origin ASN and populate `next_hop_asn` (1012). The `pkg/ipasn` + per-prefix origin ASN and populate `enrich_socket_dest_next_hop_asn` (321). The `pkg/ipasn` interface (`Attr` + LPM `Lookup`) is designed to absorb this without changing the hot-path wiring. ## Out of scope -- BGP RIB / MRT ingestion and `next_hop_asn` (1012). +- BGP RIB / MRT ingestion and `enrich_socket_dest_next_hop_asn` (321). - Enriching the *source* ASN (destination only in phase 1). - Pushing the collector OCI image to a registry / release pipeline. diff --git a/docs/locality-enrichment.md b/docs/locality-enrichment.md index 5b94ba3..62faa30 100644 --- a/docs/locality-enrichment.md +++ b/docs/locality-enrichment.md @@ -21,11 +21,29 @@ network namespace, *before* the ASN lookup: 3. otherwise → `LOCALITY_REMOTE`, and *only then* fall through to the existing IP→ASN / network-owner enrichment. -The result is stored in the new field -`inet_diag_msg_socket_dest_locality` (1019). Self and connected-subnet -destinations are tagged and skip the ASN feed, so `dest_asn` (1011) / -`dest_network_owner` (1018) stay empty for them — which is correct, since those -feeds only describe the public internet. +The result is stored in the field `enrich_socket_dest_locality` (310, in the +daemon-computed 300s enrichment block). Self and connected-subnet destinations +are tagged and skip the ASN feed, so `enrich_socket_dest_asn` (320) / +`enrich_socket_dest_network_owner` (322) stay empty for them — which is correct, +since those feeds only describe the public internet. + +The same snapshot also resolves interface names: `enrich_socket_interface_name` +(300) is the socket's bound interface (kernel `idiag_if`, field 1009, resolved via +RTM_GETLINK — usually empty since most sockets are not `SO_BINDTODEVICE`-bound), +and `enrich_socket_dest_egress_ifindex`/`enrich_socket_dest_egress_ifname` +(311/312) are the egress interface of the route the destination longest-prefix +matches — populated even for unbound sockets. + +> **Field layout (2026-09, record epoch 2).** The daemon-computed destination +> fields were moved out of the raw kernel inet_diag payload block (they were +> `..._dest_asn` 1011, `..._next_hop_asn` 1012, `..._dest_network_owner` 1018, +> `..._dest_locality` 1019) into a dedicated 300s enrichment block, renamed +> `enrich_*`, and grouped by subject: 300 socket-side, 310–349 destination-side, +> 350–389 reserved for future source-side enrichment. The old tags/names are +> `reserved` in the proto and never reused. Because this renumbered released +> fields, it shipped as `schema_version` 2 with a new ClickHouse `_v2` table — see +> [record-versioning.md](record-versioning.md) for the routing and the mixed-fleet +> caveat (epoch-1 rows lose the two renumbered egress columns during rollout). ### Why per-namespace @@ -86,7 +104,7 @@ Applied in `pkg/localnet.BuildSnapshot`, from one namespace's parsed issued with `AF_UNSPEC`, which returns *all* tables (main + local), so the local table's `RTN_LOCAL` host entries (scope host) are included and reinforce the self set. -- **Connected subnet** = a route that is `RTN_UNICAST` **and** +- **Local subnet** (`LOCALITY_LOCAL_SUBNET`) = a route that is `RTN_UNICAST` **and** `RT_SCOPE_LINK` **and** has **no** `RTA_GATEWAY` **and** carries a destination prefix. That is exactly "reachable in one L2 hop, no next-hop router". A `/0` such route is defensively dropped so it cannot swallow everything. @@ -122,9 +140,12 @@ if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok remote := true if m := x.localityByInode.Load(); m != nil { if snap := (*m)[r.NetnsInode]; snap != nil { - loc := snap.Classify(addr) - r.InetDiagMsgSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(loc) - remote = loc == localnet.LocalityRemote + res := snap.Resolve(addr, r.InetDiagMsgSocketInterface) + r.EnrichSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(res.Locality) + r.EnrichSocketDestEgressIfindex = res.EgressIfindex + r.EnrichSocketDestEgressIfname = res.EgressIfname + r.EnrichSocketInterfaceName = res.BoundIfname + remote = res.Locality == localnet.LocalityRemote } } if remote && x.asnIndex != nil { @@ -150,36 +171,80 @@ an `SO_RCVTIMEO`, and dumped (links, addresses, routes) entirely within that thread; `BuildSnapshot` produces the immutable result and the map is published with `atomic.Store`. -Refresh is throttled by `locality_refresh_interval`: a **full** pass -re-discovers every namespace; intervening passes only dump namespaces that -appeared since the last snapshot (a new container is classified promptly without -re-dumping everything). A namespace whose dump fails keeps its previous -snapshot rather than dropping to unclassified. `interval <= 0` means discover -each namespace once and never refresh it (new namespaces are still picked up). +Refresh is throttled by `locality_refresh_interval` (daemon default **60s**): +a **full** pass re-discovers every namespace; intervening (partial) passes only +dump namespaces that appeared since the last snapshot, so a new container is +classified on the very next reconcile without re-dumping everything. +`interval <= 0` means there is never another full pass — each namespace is +discovered once (plus the retries below) and never refreshed. + +Three rules keep a bad or busy fleet from turning the reconcile path into a +stall: + +- **Negative cache.** A namespace whose dump fails (`open`/`setns`/rtnetlink + error) keeps its previous snapshot and is retried on a **30s → 5m doubling + backoff**, not on every reconcile — even a full pass skips a namespace whose + retry window has not opened. Retry state is dropped when the namespace + vanishes. +- **Loopback-only re-dump.** A snapshot with no non-loopback self address + (`Snapshot.HasNonLoopbackSelf() == false`) is almost always a container whose + veth is not plumbed yet. It *is* published (loopback classifies correctly), + the namespace is re-dumped on the **next** reconcile, and if it is still + lo-only it joins the same 30s → 5m schedule. +- **Per-pass cap.** A partial pass dumps at most **32** namespaces (new ones + plus expired retries); the rest are counted as `deferred` and picked up next + reconcile, so a burst of hundreds of containers is classified over a few + reconciles instead of blocking one. Full passes are uncapped — re-dumping + everything is their job. + +Each rtnetlink dump is hardened in `pkg/xtcpnl.DumpRtnetlink`: replies are +filtered by the request's `nlmsg_seq` (a stale reply or stale `NLMSG_DONE` +from an earlier timed-out dump cannot end the current one), datagrams not from +the kernel (`nlmsg_pid != 0`) are ignored, and a reply flagged +`NLM_F_DUMP_INTR` (table changed mid-dump) drains the stream and returns +`ErrDumpInterrupted`; `dumpRetrying` then re-issues that dump with a fresh +sequence number up to 3 times before treating the namespace as failed. + +Metrics (`function="refreshLocality"`): counters `full`/`partial` (passes), +`dumped`, `failed`, `loopbackOnly`, `deferred`; gauges `namespaces` (snapshots +published) and `retryBackoff` (namespaces in the negative cache); summary +`full`/`partial` `duration`. `dumpLocality/interrupted/retry` counts +`NLM_F_DUMP_INTR` re-issues. ## Configuration (`proto/xtcp_config/v1`) -- `enrich_locality_enable` (242) — opt-in gate, off by default. -- `locality_refresh_interval` (243, `google.protobuf.Duration`) — refresh - cadence; `0` = discover-once. +- `enrich_locality_enable` (245) — opt-in gate, off by default. +- `locality_refresh_interval` (246, `google.protobuf.Duration`) — full-refresh + cadence, daemon default 60s; `0` = discover-once (new namespaces and the + failure/loopback-only retries still run). -Settable via config file / gRPC config service (matches the ASN toggle, which is -also not wired to CLI flags today). +Settable via the CLI flags `-enrichLocality` / `-localityRefreshInterval`, the +environment variables `ENRICH_LOCALITY` / `LOCALITY_REFRESH_INTERVAL`, the config +file, or the gRPC config service. (`XtcpConfig` field numbers are grouped by +subject: enrichment lives in 200–249, locality at 245/246.) ## Record + downstream schema plumbing -Following `inet_diag_msg_socket_dest_network_owner` (1018) as the checklist: +The daemon-computed fields live in the 300s enrichment block (see the field-layout +note above): - **Flat-record proto**: nested `Locality` enum (`UNSPECIFIED`/`SELF`/`LOCAL_SUBNET`/`REMOTE`) + field - `inet_diag_msg_socket_dest_locality` (1019). Regenerated into `gen/`. + `enrich_socket_dest_locality` (310), the interface fields + `enrich_socket_interface_name` (300) / + `enrich_socket_dest_egress_ifindex` (311) / + `enrich_socket_dest_egress_ifname` (312), and the relocated + `enrich_socket_dest_asn` (320) / `enrich_socket_dest_next_hop_asn` (321) / + `enrich_socket_dest_network_owner` (322). Regenerated into `gen/`. - **Parquet**: `int32` column (enums are stored numerically, like - `congestion_algorithm_enum`) in `destinations_s3parquet_schema.go`, copied in + `inet_diag_cong_enum`) in `destinations_s3parquet_schema.go`, copied in `destinations_s3parquet.go`. -- **ClickHouse**: an `Enum('unspecified'=0,'self'=1,'connected_subnet'=2, - 'remote'=3)` column in the MergeTree table and the Kafka-engine table (the - MV is `SELECT *`, so it needs no change). ClickHouse maps protobuf enums by - numeric value, so the label strings are chosen for readability. +- **ClickHouse**: an `Enum('unspecified'=0,'self'=1,'local_subnet'=2, + 'remote'=3)` column in the `_v2` MergeTree table and the Kafka-engine table. + The `_v2` MV is positional (`* EXCEPT (timestamp_ns)`); the `_v0`/`_v1` MVs + alias it through as `toUInt8(enrich_socket_dest_locality)`. ClickHouse maps + protobuf enums by numeric value, so the label strings are chosen for + readability and match the proto / `localnet.Locality.String()` spelling. - **recordfmt**: a `LocalityName` humanizer (trims the `LOCALITY_` prefix) and a humanized column case, mirroring `CongestionAlgorithmName`. diff --git a/docs/output-and-destinations.md b/docs/output-and-destinations.md index 5cb9b6a..b43065d 100644 --- a/docs/output-and-destinations.md +++ b/docs/output-and-destinations.md @@ -102,7 +102,7 @@ sudo ./result/bin/xtcp2 -dest stdout -marshal jsonl -d 1 | jq . # CSV of just the columns you care about, into a file → open in DuckDB/R sudo ./result/bin/xtcp2 -dest file:/tmp/socks.csv -marshal csv -d 1 \ - -columns hostname,inetDiagMsgSocketSource,inetDiagMsgSocketSourcePort,inetDiagMsgState,congestionAlgorithmEnum,tcpInfoRtt + -columns hostname,inetDiagMsgSocketSource,inetDiagMsgSocketSourcePort,inetDiagMsgState,inetDiagCongEnum,tcpInfoRtt duckdb -c "select inetDiagMsgState, count(*) from '/tmp/socks.csv' group by 1" # Stream NDJSON over TCP to a log shipper / nc diff --git a/docs/parquet-format.md b/docs/parquet-format.md index e6f5288..dbbea4e 100644 --- a/docs/parquet-format.md +++ b/docs/parquet-format.md @@ -79,7 +79,7 @@ df = dataset.to_table(columns=["timestamp_ns","hostname","tcp_info_rtt"]).to_pan -- partitions (host string, date string, hour string); project columns you need. ``` -**Always select only the columns you need** — there are 123, and columnar pruning is where Parquet earns its keep. Likewise filter on the `event_date` column (or the `date`/`hour` path partitions) for pruning. +**Always select only the columns you need** — there are 162, and columnar pruning is where Parquet earns its keep. Likewise filter on the `event_date` column (or the `date`/`hour` path partitions) for pruning. ## Loading into Snowflake (Snowpipe → managed table) @@ -153,14 +153,14 @@ If you're scoping an initial implementation, these are the high-value columns. E |---|---|---| | `tcp_info_rtt` | uint32 | Smoothed round-trip time, **microseconds**. The headline latency metric. | | `tcp_info_min_rtt` | uint32 | Minimum RTT seen, microseconds — a cleaner latency baseline. | -| `tcp_info_rtt_var` | uint32 | RTT variance, microseconds (jitter). | +| `tcp_info_rttvar` | uint32 | RTT variance, microseconds (jitter). | | `tcp_info_snd_cwnd` | uint32 | Congestion window, **in packets/segments** (not bytes). | | `tcp_info_total_retrans` | uint32 | Cumulative retransmitted segments — the simplest "is this connection healthy?" signal. | | `tcp_info_bytes_sent` / `tcp_info_bytes_acked` | uint64 | Cumulative bytes sent / acknowledged. | | `tcp_info_bytes_received` | uint64 | Cumulative bytes received. | | `tcp_info_delivery_rate` | uint64 | Recent delivery rate, **bytes/second** — effective throughput. | | `tcp_info_pacing_rate` | uint64 | Sender pacing rate, bytes/second. | -| `congestion_algorithm_string` | string | Congestion-control algorithm name (e.g. `cubic`, `bbr`) — easiest to read. | +| `inet_diag_cong` | string | Congestion-control algorithm name (e.g. `cubic`, `bbr`) — easiest to read. | A solid first dashboard: per host/destination, `MAX(tcp_info_rtt)` and `MAX(tcp_info_min_rtt)`, the delta of `tcp_info_total_retrans`, and throughput from `tcp_info_delivery_rate` — filtered to `inet_diag_msg_state = 1` (ESTABLISHED). @@ -180,31 +180,33 @@ A few columns are stored as machine values for fidelity/size and need decoding f | 5 | FIN_WAIT2 | 11 | CLOSING | | 6 | TIME_WAIT | 12 | NEW_SYN_RECV | -- **Congestion algorithm**: prefer `congestion_algorithm_string` (the kernel name). The `congestion_algorithm_enum` integer is `0`=UNSPECIFIED, `1`=CUBIC, `2`=DCTCP, `3`=VEGAS, `4`=PRAGUE, `5`=BBR1, `6`=BBR2, `7`=BBR3. +- **Congestion algorithm**: prefer `inet_diag_cong` (the kernel name). The `inet_diag_cong_enum` integer is `0`=UNSPECIFIED, `1`=CUBIC, `2`=DCTCP, `3`=VEGAS, `4`=PRAGUE, `5`=BBR1, `6`=BBR2, `7`=BBR3. - **timestamp_ns** is an int64 of epoch nanoseconds; `to_timestamp(timestamp_ns / 1e9)` (or your engine's equivalent) gives a UTC timestamp. ## Full schema and column types -The complete column list (123 columns) groups as follows; column names are the proto's snake_case names, identical to the ClickHouse table columns — the one exception is `event_date`, a Parquet-only derived column with no proto/ClickHouse counterpart: +The complete column list (162 columns, in proto field-number order) groups as follows; column names are the proto's snake_case names, identical to the ClickHouse `_v2` table columns — the one exception is `event_date`, a Parquet-only derived column with no proto/ClickHouse counterpart: -- **Metadata** — `timestamp_ns` (int64), `event_date` (string, derived — UTC date of `timestamp_ns`), `hostname`, `netns`, `nsid`, `label`, `tag`, `record_counter`, `socket_fd`, `netlinker_id`. -- **`inet_diag_msg_*`** — the socket id/4-tuple, state, queues, uid/inode, ASN annotations. +- **Metadata** — `schema_version`, `daemon_version`, `timestamp_ns` (int64), `event_date` (string, derived — UTC date of `timestamp_ns`), `hostname`, `location`, `netns`, `netns_inode`, `nsid`, `container_*`, `label`, `tag`, `record_counter`, `socket_fd`, `netlinker_id`, and the two host-uplink blocks `uplink1_*` / `uplink2_*` (NIC + LLDP neighbour). +- **`enrich_*`** — daemon-computed: bound interface name, destination locality (`int32` enum: `0`=UNSPECIFIED, `1`=SELF, `2`=LOCAL_SUBNET, `3`=REMOTE), egress interface, destination ASN / next-hop ASN / network owner. +- **`inet_diag_msg_*`** — the socket id/4-tuple, state, queues, uid/inode (kernel `struct inet_diag_msg`). - **`mem_info_*` / `sk_mem_info_*`** — socket memory accounting. -- **`tcp_info_*`** — the bulk of the data: RTT, cwnd, ssthresh, MSS, windows, segment and byte counters, pacing/delivery rates, RTO stats, busy/limited times. -- **`congestion_algorithm_*`** — enum (`int32`) + string name. +- **`tcp_info_*`** — the bulk of the data: RTT, cwnd, ssthresh, MSS, windows, segment and byte counters, pacing/delivery rates, RTO stats, busy/limited times (kernel `struct tcp_info`, member names preserved). +- **`inet_diag_cong` / `inet_diag_cong_enum`** — congestion-control name string + derived enum (`int32`). +- **`inet_diag_tos` / `inet_diag_tclass` / `inet_diag_shutdown`** — QoS and shutdown state. - **Per-algorithm blocks** — `vegas_info_*`, `dctcp_info_*`, `bbr_info_*` (only meaningful when that algorithm is in use). -- **QoS / misc** — `type_of_service`, `traffic_class`, `shutdown_state`, `class_id`, `sock_opt`, `c_group`. +- **`inet_diag_class_id` / `inet_diag_sockopt` / `inet_diag_cgroup_id`** — traffic class id, socket option bits, cgroup id. -Column types are: `int64` (timestamp only), `string` (hostname/netns/label/tag/congestion string), `bytes` (the two IP-address columns), `int32` (congestion enum), and `uint32`/`uint64` for everything else. The authoritative, field-by-field list with types and compression is the [`ParquetRow` struct](../pkg/xtcp/destinations_s3parquet_schema.go); field meanings are in the [protobuf schema](../proto/xtcp_flat_record/v1/xtcp_flat_record.proto) and [protobuf-formats.md](protobuf-formats.md). +Column types are: `int64` (timestamp only), `string` (hostname/netns/labels/uplink strings/congestion string), `bytes` (the two IP-address columns), `int32` (the two enums), and `uint32`/`uint64` for everything else. The authoritative, field-by-field list with types and compression is the [`ParquetRow` struct](../pkg/xtcp/destinations_s3parquet_schema.go); field meanings are in the [protobuf schema](../proto/xtcp_flat_record/v1/xtcp_flat_record.proto) and [protobuf-formats.md](protobuf-formats.md). ## Types, nulls, and gotchas - **No NULLs.** The records come from proto3, which has no null — an absent/zero value is the numeric `0` (or empty string/bytes). Treat `0` as "unset or genuinely zero"; don't expect SQL `NULL`. - **Counters are cumulative**, per socket lifetime — delta between consecutive polls (matched by `inet_diag_msg_socket_cookie`) for per-interval rates, or `MAX()` for totals. - **Units differ**: RTTs are microseconds; rates are bytes/second; `snd_cwnd` is packets; byte counters are bytes. The per-column units are in the tables above. -- **Per-algorithm columns are sparse-in-meaning**: `bbr_info_*` is only populated when the socket uses BBR, etc. Filter on `congestion_algorithm_string` before trusting them. +- **Per-algorithm columns are sparse-in-meaning**: `bbr_info_*` is only populated when the socket uses BBR, etc. Filter on `inet_diag_cong` before trusting them. - **`event_date` is per-sample, not the file's write date.** It's the UTC date of each row's own `timestamp_ns`, so it ≈ the `date=` path segment but can differ for a file that spans UTC midnight (the column is the more precise one). It's a distinct column name from the hive `date` partition, so `hive_partitioning = true` reads expose both without collision. An unset `timestamp_ns` (0) yields `1970-01-01`. For exact sub-day or boundary filtering, use `timestamp_ns`. -- **Schema evolution**: new fields are *added* (never renamed/reordered in place), so plan for forward-compatible reads (select by name, tolerate new columns). +- **Schema evolution**: within a `schema_version` epoch, fields are only *added*, so plan for forward-compatible reads (select by name, tolerate new columns). A rename ships as a **`schema_version` bump** with a new column set; files written by older daemons keep the old names. Branch on `schema_version` when reading across the boundary. The epoch 1 → 2 rename table (e.g. `tcp_info_rtt_var` → `tcp_info_rttvar`, `congestion_algorithm_string` → `inet_diag_cong`, `c_group` → `inet_diag_cgroup_id`) is in [record-versioning.md](record-versioning.md#epoch-1--2-rename-table). ## Where the schema is defined diff --git a/docs/protobuf-formats.md b/docs/protobuf-formats.md index edfd7cf..cbd368c 100644 --- a/docs/protobuf-formats.md +++ b/docs/protobuf-formats.md @@ -72,8 +72,8 @@ This is the exported TCP data. Two core messages: hostname, network namespace, the `inet_diag` message fields, the full `tcp_info`, socket memory, congestion-control state (BBR/DCTCP/Vegas), cgroup/class IDs, and more. The flatness is what makes CSV/TSV and tabular analysis easy. Addresses are raw `bytes`; the - congestion algorithm is the `CongestionAlgorithm` enum (`CONGESTION_ALGORITHM_CUBIC` … - `BBR3`) with a string fallback field. + congestion algorithm is the kernel's name string (`inet_diag_cong`) plus the derived + `CongestionAlgorithm` enum (`inet_diag_cong_enum`, `CONGESTION_ALGORITHM_CUBIC` … `BBR3`). - **`Envelope { repeated XtcpFlatRecord row }`** — a batch of records. This is the unit the daemon marshals and ships; framed length-delimited it is exactly ClickHouse's `ProtobufList` input format. See [protobuflist-migration.md](protobuflist-migration.md) for the wire-format @@ -82,22 +82,57 @@ This is the exported TCP data. Two core messages: Every record carries two provenance fields at the low field numbers: - **`schema_version` (field 1)** — the record *format epoch*, stamped unconditionally from the - daemon constant `XtcpFlatRecordSchemaVersion` (currently `1`). Bump it whenever the format - changes meaningfully. `0` is the "legacy" bucket: pre-versioning daemons never set the field, + daemon constant `XtcpFlatRecordSchemaVersion` (currently `2`). Bump it whenever a field is + renamed or renumbered. `0` is the "legacy" bucket: pre-versioning daemons never set the field, so it decodes to the proto3 zero default. Downstream this drives per-version ClickHouse routing — see [record-versioning.md](record-versioning.md). - **`daemon_version` (field 2)** — build provenance (git commit / date / version from `-ldflags`), for debugging which binary produced a row. Informational only; not used for routing. +### Field layout policy + +The field-number space is allocated in blocks so that related fields stay together, every +block has headroom, and nothing is ever reused (the proto's header comment is the +authoritative copy of this policy): + +| Range | Contents | Notes | +|---|---|---| +| 1–2 | `schema_version`, `daemon_version` | single-byte tags | +| 3–299 | metadata (host, netns, container, labels, bookkeeping, uplink slots 100s/200s) | numbers frozen; free sub-ranges listed in the proto | +| 300–399 | enrichment (daemon-computed, not from the kernel) | 300 socket-side · 310–349 destination-side · 350–389 reserved for future source-side | +| 400–999 | spare | | +| 1000+ | payload, one hundred-block per kernel subsystem | `inet_diag_msg` 1000s · `meminfo` 1100s (deprecated) · `tcp_info` 1200s · `cong` 1300s · `tos/tclass` 1400s · `skmeminfo` 1500s · `shutdown` 1600s · `vegas` 1700s · `dctcp` 1800s · `bbr` 1900s · `class_id/sockopt/cgroup_id` 2000s; next free block 2100 | + +Every tag ≤ 2047 costs two bytes on the wire (2048+ costs three), so free slots inside +existing blocks are filled before a new block is opened above 2047. + +**Payload names mirror the kernel.** A payload field is named after the kernel struct member +it copies (`tcpi_rttvar` → `tcp_info_rttvar`, `SK_MEMINFO_RCVBUF` → `sk_mem_info_rcvbuf`), +and struct-less `INET_DIAG_*` attributes take the lowercased attribute name (`INET_DIAG_TOS` +→ `inet_diag_tos`, `INET_DIAG_CGROUP_ID` → `inet_diag_cgroup_id`). The one deliberate +exception is the descriptive `inet_diag_msg_socket_{source,destination,…}` sockid names. +Every payload field carries a trailing comment naming its kernel source, e.g. +`// struct tcp_info.tcpi_rttvar (__u32)`, `// SK_MEMINFO_RCVBUF (__u32, sock_diag.h)`, +`// INET_DIAG_TOS (5): inet->tos (__u8, net/ipv4/inet_diag.c)`, or +`// derived by xtcp from inet_diag_cong (not a kernel field)`. `go run ./tools/proto-field-audit` +fails if a field with tag ≥ 1000 lacks such a comment. Members the deserializer does not +read yet (the post-6.10 AccECN `tcp_info` fields) are pre-assigned by comment at 1266–1276. + +Epoch 2 (2026-09) applied this policy retroactively: 18 payload fields and one enrichment +field were renamed and three were renumbered. The full old → new table lives in +[record-versioning.md](record-versioning.md#epoch-1--2-rename-table); the old names and +numbers are `reserved` in the proto. + > **Deprecated: `mem_info_*` (fields 1101–1104).** These four socket-memory fields are a > value-subset of the `sk_mem_info_*` fields (`mem_info_rmem`=`sk_mem_info_rmem_alloc`, > `mem_info_wmem`=`sk_mem_info_wmem_queued`, `mem_info_fmem`=`sk_mem_info_fwd_alloc`, > `mem_info_tmem`=`sk_mem_info_wmem_alloc`) — the kernel derives both from the same `sk` > counters. The `meminfo` deserializer is off by default, so on current records these columns > ship as `0`; use `sk_mem_info_*` instead (see [netlink-collection.md](netlink-collection.md)). -> The fields are **retained** (never renumbered), so `schema_version` stays `1`: the record is -> structurally identical and the data is fully recoverable from `sk_mem_info_*`. +> The fields are **retained** (never renumbered), so the deprecation alone did not bump +> `schema_version`: the record is structurally identical and the data is fully recoverable +> from `sk_mem_info_*`. It also defines the streaming **`XTCPFlatRecordService`**, which `xtcp2client` consumes: diff --git a/docs/protobuflist-migration.md b/docs/protobuflist-migration.md index a08f1f9..0df26cc 100644 --- a/docs/protobuflist-migration.md +++ b/docs/protobuflist-migration.md @@ -62,7 +62,7 @@ Cut a new feature branch `protobuf-list-migration` from current HEAD (`complexit | `proto/xtcppb.proto.old` | Archived backup (suffix `.old`) | **DELETE** in Phase 7 (cleanup; not load-bearing) | | `cmd/xtcp2/xtcp_flat_record.proto` | Embedded runtime copy — daemon reads this and POSTs to schema registry at startup | **EDIT**: identical structural change as canonical. Verify with `diff` after edit. | | `build/containers/clickhouse/format_schemas/xtcp_flat_record.proto` | Bind-mounted into ClickHouse at `/var/lib/clickhouse/format_schemas/` (per `docker-compose.yml:55-70`, `mkVm.nix:133-138`); referenced by `kafka_schema` setting | **EDIT**: identical structural change. ClickHouse Phase 3 SQL references `xtcp_flat_record.proto:xtcp_flat_record.v1.Envelope` which lives in THIS copy. | -| `build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto` | Alternate format-schema (package `xtcp_flat_record_repeated.v1`, top-level only, no Envelope) referenced by `xtcp_xtcp_flat_records_kafka_testing.sql` | **DELETE** — Phase 3 retires the testing.sql variant. This proto is only consumed by the testing SQL; no other references in code. Verify via `grep -rn xtcp_flat_record_repeated /home/das/Downloads/xtcp2 --exclude-dir=.git`. | +| `build/containers/clickhouse/format_schemas/xtcp_flat_record_repeated.proto` | Alternate format-schema (package `xtcp_flat_record_repeated.v1`, top-level only, no Envelope) referenced by `xtcp_xtcp_flat_records_kafka_testing.sql` | **DELETED (2026-09, record epoch 2)** — was only consumed by the retired testing SQL. The single Kafka format schema is now the generated `format_schemas/xtcp_flat_record.proto`. | | `build/k8s/clickhouse/flatxtcppb.proto.configMap.yaml` | K8s ConfigMap, contains an OLD pre-flat-record schema (package `flatxtcppb.v1`, field numbers `sec=1, nsec=2, hostname=3` — incompatible with current canonical) | **REWRITE** the embedded proto block to match the canonical refactored proto (package `xtcp_flat_record.v1`, current field numbers). Or **DELETE** the file entirely if K8s clickhouse deployment is not currently in use (`grep -rn flatprotobuf-configmap /home/das/Downloads/xtcp2 --include='*.yaml' --exclude-dir=.git` — if only the configmap itself references the name, it's dead and can be deleted). | | `build/k8s/clickhouse/example.proto.configMap.yaml` | Another K8s ConfigMap example | **AUDIT**: read and confirm whether it references xtcp_flat_record; update or leave per inventory finding. | diff --git a/docs/record-versioning.md b/docs/record-versioning.md index e018dc7..dc2546e 100644 --- a/docs/record-versioning.md +++ b/docs/record-versioning.md @@ -18,8 +18,7 @@ Both live in `proto/xtcp_flat_record/v1/xtcp_flat_record.proto` at the lowest `schema_version = 0` is reserved for **pre-versioning daemons**: they never set the field, so proto3 decodes it to zero. That makes `0` a free "legacy" bucket — no -change is needed on already-deployed old daemons. The current (enrichment-era) -format is epoch **1**. +change is needed on already-deployed old daemons. Why per-row and not on the `Envelope`? ClickHouse's `ProtobufList` format maps the **row** type and consumes the envelope framing itself, so envelope fields never @@ -31,41 +30,119 @@ every build, whereas `schema_version` bumps only when the record format changes enough to warrant a new physical table. Tying the epoch to the release version would spawn a new `_vN` table on every release. +## Epoch history + +| Epoch | When | What changed | +|---|---|---| +| 0 | pre-2026-08 | No `schema_version` on the wire. | +| 1 | 2026-08/09 | Metadata blocks 1–299, enrichment block 300s, payload 1000+. Fields only added. | +| 2 | 2026-09 | Payload field names aligned to the **kernel struct member spelling**, the 300s enrichment block regrouped by subject, `XtcpConfig` renumbered. See the rename table below and the layout policy in [protobuf-formats.md](protobuf-formats.md#field-layout-policy). | + +**When to bump.** Any field **rename or renumber** bumps the epoch. Adding a field +in a free slot does not: ClickHouse and Parquet map by name, so new columns simply +read as default on older rows. + +### Epoch 1 → 2 rename table + +Wire tag unchanged unless noted. Because the ClickHouse Kafka table maps column +name → proto field → tag, a same-tag rename still decodes epoch-1 bytes correctly; +only the three renumbered fields are lost for epoch-1 rows during a mixed rollout. + +| Epoch 2 name | Epoch 0/1 name | Tag | Kernel source | +|---|---|---|---| +| `enrich_socket_dest_egress_ifindex` | same | **301 → 311** | daemon-derived | +| `enrich_socket_dest_egress_ifname` | same | **302 → 312** | daemon-derived | +| `enrich_socket_dest_next_hop_asn` | `enrich_socket_next_hop_asn` | 321 | daemon-derived | +| `tcp_info_snd_wscale` | `tcp_info_send_scale` | 1207 | `tcp_info.tcpi_snd_wscale` | +| `tcp_info_rcv_wscale` | `tcp_info_rcv_scale` | 1208 | `tcp_info.tcpi_rcv_wscale` | +| `tcp_info_fastopen_client_fail` | `tcp_info_fast_open_client_failed` | 1210 | `tcp_info.tcpi_fastopen_client_fail` | +| `tcp_info_rttvar` | `tcp_info_rtt_var` | 1231 | `tcp_info.tcpi_rttvar` | +| `tcp_info_advmss` | `tcp_info_adv_mss` | 1234 | `tcp_info.tcpi_advmss` | +| `tcp_info_notsent_bytes` | `tcp_info_not_sent_bytes` | 1245 | `tcp_info.tcpi_notsent_bytes` | +| `inet_diag_cong` | `congestion_algorithm_string` | 1300 | `INET_DIAG_CONG` | +| `inet_diag_cong_enum` | `congestion_algorithm_enum` | 1301 | derived from 1300 | +| `inet_diag_tos` | `type_of_service` | 1401 | `INET_DIAG_TOS` | +| `inet_diag_tclass` | `traffic_class` | 1402 | `INET_DIAG_TCLASS` | +| `sk_mem_info_rcvbuf` | `sk_mem_info_rcv_buf` | 1502 | `SK_MEMINFO_RCVBUF` | +| `sk_mem_info_sndbuf` | `sk_mem_info_snd_buf` | 1504 | `SK_MEMINFO_SNDBUF` | +| `inet_diag_shutdown` | `shutdown_state` | 1600 | `INET_DIAG_SHUTDOWN` | +| `vegas_info_rttcnt` | `vegas_info_rtt_cnt` | 1702 | `tcpvegas_info.tcpv_rttcnt` | +| `vegas_info_minrtt` | `vegas_info_min_rtt` | 1704 | `tcpvegas_info.tcpv_minrtt` | +| `inet_diag_class_id` | `class_id` | 2001 | `INET_DIAG_CLASS_ID` | +| `inet_diag_sockopt` | `sock_opt` | 2002 | `INET_DIAG_SOCKOPT` | +| `inet_diag_cgroup_id` | `c_group` | **2103 → 2003** | `INET_DIAG_CGROUP_ID` | + +The ClickHouse `Locality` enum label for value 2 also changed from +`connected_subnet` to `local_subnet` (matching the proto `LOCALITY_LOCAL_SUBNET` +and the `localnet` package). Values are unchanged. + ## ClickHouse topology -One Kafka topic (`xtcp`) → one Kafka engine table → **two materialized views that -fan out by `schema_version`** → per-version MergeTree tables. ClickHouse supports -multiple MVs reading one Kafka engine table, so routing stays a ClickHouse-only -concern on the single topic. DDL: `build/containers/clickhouse/initdb.d/sql/`. +One Kafka topic (`xtcp`) → one Kafka engine table → **one materialized view per +epoch, fanning out by `schema_version`** → per-version MergeTree tables. ClickHouse +supports multiple MVs reading one Kafka engine table, so routing stays a +ClickHouse-only concern on the single topic. DDL: +`build/containers/clickhouse/initdb.d/sql/`. ``` -topic xtcp → xtcp.xtcp_flat_records_kafka +topic xtcp → xtcp.xtcp_flat_records_kafka (epoch-2 column names, proto order) ├─ xtcp_flat_records_v0_mv : WHERE _error=='' AND schema_version = 0 → xtcp.xtcp_flat_records_v0 (legacy) - ├─ xtcp_flat_records_v1_mv : WHERE _error=='' AND schema_version = 1 → xtcp.xtcp_flat_records_v1 (current) + ├─ xtcp_flat_records_v1_mv : WHERE _error=='' AND schema_version = 1 → xtcp.xtcp_flat_records_v1 (epoch 1) + ├─ xtcp_flat_records_v2_mv : WHERE _error=='' AND schema_version = 2 → xtcp.xtcp_flat_records_v2 (current) └─ xtcp_flat_records_errors_mv : WHERE _error<>'' → xtcp.xtcp_flat_records_errors -xtcp.xtcp_flat_records = Merge('xtcp', '^xtcp_flat_records_v[0-9]+$') -- cross-version query surface +xtcp.xtcp_flat_records = Merge('xtcp', '^xtcp_flat_records_v[0-9]+$') -- cross-version query surface, AS _v2 ``` -- **`xtcp_flat_records`** is now a read-only `Merge` view spanning every - `_v[0-9]+` table, so existing queries/dashboards that hit `xtcp_flat_records` - keep working and transparently span all versions. Its `_table` virtual column - tells you which physical version a row came from. -- **`_v1` is created `AS _v0`**, so the two physical tables share structure/engine/ - `ORDER BY`/TTL and cannot drift. -- The positional MV convention (`SELECT fromUnixTimestamp64Nano(timestamp_ns) AS - timestamp_ns, * EXCEPT (timestamp_ns)`) is preserved: `schema_version` and - `daemon_version` are declared right after `timestamp_ns` in the Kafka table and - every destination table so the positional insert stays aligned. +- **`xtcp_flat_records`** is a read-only `Merge` view spanning every `_v[0-9]+` + table, so existing queries/dashboards that hit `xtcp_flat_records` keep working + and transparently span all versions. Its `_table` virtual column tells you which + physical version a row came from. It is declared `AS _v2` (the newest, superset + column set); a column an older table lacks reads as default for that table's + rows, so **branch on `schema_version`** when a renamed column matters (epoch-0/1 + rows keep their data under the old names in `_v0` / `_v1`). +- **`_v1` is created `AS _v0`** (epoch 1 only added fields). **`_v2` has its own + full DDL** because epoch 2 renamed columns. +- **MV → table mapping is by column NAME**, not position (a `TO` MV is an + `INSERT ... SELECT`). `_v2_mv` therefore uses the short + `fromUnixTimestamp64Nano(timestamp_ns) AS timestamp_ns, * EXCEPT (timestamp_ns)` + form, while `_v0_mv` / `_v1_mv` carry an **explicit select list** aliasing every + renamed column back to the old name (`tcp_info_rttvar AS tcp_info_rtt_var`, + `inet_diag_cgroup_id AS c_group`, …). The two Enum columns pass through as + `toUInt8(...)` so the insert does not depend on the target's enum labels. + +### Mixed fleet during the epoch-1 → 2 rollout + +The Kafka table decodes against the epoch-2 schema +(`format_schemas/xtcp_flat_record.proto`). For rows produced by epoch-1 daemons: + +- renamed-only fields keep their tag → decode into the epoch-2-named column → the + `_v1` MV aliases them back → **no data loss**; +- the three **renumbered** fields (`enrich_socket_dest_egress_ifindex/ifname`, + `c_group`) are unknown tags → **dropped**; `_v1` reads them as `0`/`''` for rows + produced after the ClickHouse migration until the daemon fleet is on epoch 2. + Roll daemons promptly after migrating ClickHouse. ## Adding a new epoch 1. Change the record format in the proto; `nix run .#regen-protos`. -2. Bump `XtcpFlatRecordSchemaVersion` in `pkg/xtcp/schema_version.go` (and the - guard in `pkg/xtcp/deserialize_test.go`). -3. In `build/containers/clickhouse/initdb.d/sql/`: add `xtcp_flat_records_v2` - (`CREATE ... AS xtcp_flat_records_v0` + the new columns) and a - `xtcp_flat_records_v2_mv` (`WHERE schema_version = 2`). The `Merge` regex picks - up `_v2` automatically — no edit to the union surface. + Every payload field (tag ≥ 1000) must carry its kernel-source trailing comment + (`go run ./tools/proto-field-audit` enforces this). +2. Bump `XtcpFlatRecordSchemaVersion` in `pkg/xtcp/schema_version.go` (append to its + history comment) and the guard in `pkg/xtcp/deserialize_test.go`. +3. In `build/containers/clickhouse/initdb.d/sql/`: + - `xtcp_xtcp_flat_records_kafka.sql`: Kafka table = the new column set, in proto + order. + - `xtcp_xtcp_flat_records.sql`: add `xtcp_flat_records_vN`. Use + `CREATE ... AS _v(N-1)` only if nothing was renamed; otherwise write the full + DDL. Re-declare the `Merge` view `AS _vN`. + - `xtcp_xtcp_flat_records_mv.sql`: add `_vN_mv` (`WHERE schema_version = N`, + `* EXCEPT (timestamp_ns)` form). If columns were renamed, rewrite every older + `_vM_mv` with an explicit alias list mapping new → old names. +4. Add `build/containers/clickhouse/sql/migrations/vN.sql` for existing deployments + (drop/recreate the Kafka table + MVs, create `_vN`, re-declare the Merge view); + `v2.sql` is the template. +5. Mirror the field set in `ParquetRow` (`TestS3ParquetSchema_matchesProto` fails + otherwise) and update this document's history/rename tables. Old records keep flowing to their existing `_vN` table; new records land in the new one. Because ClickHouse maps columns by **name** and absent proto3 scalars @@ -78,4 +155,7 @@ enough to warrant a physically separate table. Nothing new is required on the host: `schema_version` is compile-time and `daemon_version` comes from the existing build `-ldflags`. The versioned DDL ships inside the ClickHouse image build; a fleet image rebuild (runpod/xtcp2) carries the -new binary + DDL. ansible-host needs no change for this feature. +new binary + DDL. Existing ClickHouse deployments apply +`build/containers/clickhouse/sql/migrations/v2.sql` (after copying the regenerated +`format_schemas/xtcp_flat_record.proto` into the server's `format_schemas/` +directory). ansible-host needs no change for this feature. diff --git a/docs/socket-analysis.md b/docs/socket-analysis.md index f09be67..94547c5 100644 --- a/docs/socket-analysis.md +++ b/docs/socket-analysis.md @@ -33,7 +33,7 @@ Treat these as **hypotheses, not constants.** The actual band count, centroids, Use **`tcp_info_min_rtt`** as the primary banding feature, not the smoothed `tcp_info_rtt` (srtt): - `min_rtt` is the *minimum* RTT the kernel has seen on the socket — it approximates the propagation/path floor and is largely free of transient queueing and load. That makes it a clean proxy for distance/path, which is exactly what bands are about. -- `tcp_info_rtt` (srtt) is useful as a *current latency* feature and, together with `tcp_info_rtt_var`, as a **jitter** signal — but it inflates under load, so it's noisier for geography. +- `tcp_info_rtt` (srtt) is useful as a *current latency* feature and, together with `tcp_info_rttvar`, as a **jitter** signal — but it inflates under load, so it's noisier for geography. **All RTT fields are microseconds** — divide by 1000 for milliseconds. RTT spans several orders of magnitude (0.1 ms intra-DC to 300 ms mobile), so **analyze it on a log scale**; the modes that correspond to bands are far clearer in `log10(min_rtt_ms)` than in linear space. @@ -88,13 +88,13 @@ Standardize (z-score) after log-transforming the heavy-tailed features. Algorith | **GMM** | Soft assignments; BIC picks K; elliptical clusters | Assumes Gaussian components | | **HDBSCAN** | No K; arbitrary shapes; **labels outliers as noise** | Sensitive to `min_cluster_size`; needs scaled features | -**HDBSCAN is the recommended default** here — it doesn't need a predetermined cluster count and its built-in noise label naturally captures the "outliers" band (item 4 above) instead of forcing every socket into a group. Use PCA or UMAP to project to 2-D for a scatter plot colored by cluster. Validate with silhouette score (or BIC for GMM), **stability across time windows** (do the same clusters reappear tomorrow?), and **external agreement** — clusters should line up with `dest_asn`, `congestion_algorithm_string`, or DC. +**HDBSCAN is the recommended default** here — it doesn't need a predetermined cluster count and its built-in noise label naturally captures the "outliers" band (item 4 above) instead of forcing every socket into a group. Use PCA or UMAP to project to 2-D for a scatter plot colored by cluster. Validate with silhouette score (or BIC for GMM), **stability across time windows** (do the same clusters reappear tomorrow?), and **external agreement** — clusters should line up with `dest_asn`, `inet_diag_cong`, or DC. ## Other useful analyses - **Throughput bands.** `log(tcp_info_delivery_rate)` is heavy-tailed; cluster it to separate "elephant" flows from "mice." Exclude `tcp_info_delivery_rate_app_limited = 1` rows when you want *path* capacity (those flows were limited by the application, not the network). - **Retransmission / loss bands.** `bytes_retrans / bytes_sent` (or `total_retrans / segs_out`) splits healthy (~0) from lossy paths. Cross-tab with the RTT band — high-RTT mobile paths often also show elevated loss. -- **Congestion-algorithm comparison.** Group by `congestion_algorithm_string` (e.g. BBR vs CUBIC) and compare RTT/throughput/loss distributions for the same destination band. +- **Congestion-algorithm comparison.** Group by `inet_diag_cong` (e.g. BBR vs CUBIC) and compare RTT/throughput/loss distributions for the same destination band. - **Per-ASN / per-CDN performance.** Aggregate by `inet_diag_msg_socket_dest_asn` to rank CDN edges or transit providers by latency and loss from each DC. - **Diurnal patterns.** Bucket by hour-of-day (`timestamp_ns`); mobile/last-mile RTT typically rises in the evening peak. Useful for capacity planning. - **Anomaly / drift detection.** Monitor band centroids over time; a sudden shift is a strong signal of a routing change or incident. @@ -117,13 +117,13 @@ WITH socket AS ( inet_diag_msg_socket_dest_asn AS dest_asn, MIN(tcp_info_min_rtt) / 1000.0 AS min_rtt_ms, MEDIAN(tcp_info_rtt) / 1000.0 AS srtt_ms, - MEDIAN(tcp_info_rtt_var) / 1000.0 AS rtt_var_ms, + MEDIAN(tcp_info_rttvar) / 1000.0 AS rtt_var_ms, MAX(tcp_info_delivery_rate) * 8.0 / 1e6 AS mbps, MAX(tcp_info_snd_cwnd) AS cwnd, -- cumulative counters: last value ≈ MAX over the socket's life MAX(tcp_info_bytes_sent) AS bytes_sent, MAX(tcp_info_bytes_retrans) AS bytes_retrans, - ANY_VALUE(congestion_algorithm_string) AS congestion, + ANY_VALUE(inet_diag_cong) AS congestion, COUNT(*) AS samples FROM read_parquet('s3://bucket/xtcp/**/*.parquet', hive_partitioning => true) WHERE inet_diag_msg_state = 1 -- ESTABLISHED only diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.grpc.pb.h b/gen/cpp/xtcp_config/v1/xtcp_config.grpc.pb.h index 092eb13..06c7b33 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.grpc.pb.h +++ b/gen/cpp/xtcp_config/v1/xtcp_config.grpc.pb.h @@ -5,8 +5,8 @@ // // xTCP - config // -// These are all the structs relating to the TCP diagnotic module in the kernel -// +// Runtime configuration of the xtcp2 daemon, served and mutated over gRPC +// (ConfigService) and mirrored one-to-one by the cmd/xtcp2 CLI flags / env. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder // diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc index 179b545..e256e16 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.cc @@ -1515,9 +1515,9 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const { PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_._has_bits_), 0, // no _extensions_ - 243, 248, // max_field_number, fast_idx_mask + 246, 248, // max_field_number, fast_idx_mask offsetof(ParseTableT_, field_lookup_table), - 3757571583, // skipmap + 4278190591, // skipmap offsetof(ParseTableT_, field_entries), 71, // num_field_entries 9, // num_aux_entries @@ -1540,237 +1540,252 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const {::_pbi::TcParser::MiniParse, {}}, {::_pbi::TcParser::MiniParse, {}}, // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { - {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(XtcpConfig, _impl_.nl_timeout_milliseconds_), 7>(), - {80, 7, 0, + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(XtcpConfig, _impl_.nl_timeout_milliseconds_), 8>(), + {80, 8, 0, PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nl_timeout_milliseconds_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - // uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { - {::_pbi::TcParser::FastV32S2, - {1408, 13, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_mply_)}}, - // string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { - {::_pbi::TcParser::FastUS2, - {2186, 2, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_secret_key_)}}, - // uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { - {::_pbi::TcParser::FastV32S2, - {912, 9, 0, + // .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { + {::_pbi::TcParser::FastMtS1, + {90, 5, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_frequency_)}}, + // .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { + {::_pbi::TcParser::FastMtS1, + {98, 6, 1, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_timeout_)}}, + // uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(XtcpConfig, _impl_.poll_jitter_pct_), 10>(), + {104, 10, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_)}}, + // uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(XtcpConfig, _impl_.max_loops_), 9>(), + {112, 9, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.max_loops_)}}, + // uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(XtcpConfig, _impl_.netlinkers_), 11>(), + {120, 11, 0, PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_)}}, - // uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { + // uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { {::_pbi::TcParser::FastV32S2, - {920, 10, 0, + {384, 12, 0, PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_done_chan_size_)}}, - // .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { - {::_pbi::TcParser::FastMtS2, - {418, 5, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_frequency_)}}, - // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { - {::_pbi::TcParser::FastUS2, - {2218, 3, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_region_)}}, - // uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { + // uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { + {::_pbi::TcParser::FastV32S2, + {392, 13, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nlmsg_seq_)}}, + // uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { {::_pbi::TcParser::FastV64S2, - {1200, 11, 0, + {400, 14, 0, PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_)}}, - // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { + // uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { {::_pbi::TcParser::FastV32S2, - {2232, 16, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_)}}, - // uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { + {408, 16, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_mply_)}}, + // uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { {::_pbi::TcParser::FastV64S2, - {704, 8, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.max_loops_)}}, - // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { - {::_pbi::TcParser::FastUS2, - {2250, 4, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_app_name_)}}, - // uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { - {::_pbi::TcParser::FastV32S2, - {1488, 14, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.write_files_)}}, - // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { + {416, 15, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_)}}, + // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { + {::_pbi::TcParser::FastMtS2, + {426, 7, 2, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_)}}, + // bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { + {::_pbi::TcParser::FastV8S2, + {432, 19, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_)}}, + // uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { {::_pbi::TcParser::FastV32S2, - {2008, 15, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_rows_)}}, - // uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { + {440, 17, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_)}}, + // uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { {::_pbi::TcParser::FastV32S2, - {992, 12, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nlmsg_seq_)}}, - // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { + {448, 18, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_)}}, + // bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; + {::_pbi::TcParser::FastV8S2, + {712, 20, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_)}}, + // bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { + {::_pbi::TcParser::FastV8S2, + {1744, 21, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_)}}, + // string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { {::_pbi::TcParser::FastUS2, - {2026, 0, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_endpoint_)}}, - // .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { - {::_pbi::TcParser::FastMtS2, - {498, 6, 1, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_timeout_)}}, - // string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { + {2778, 4, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_app_name_)}}, + // string dest = 60 [json_name = "dest", (.buf.validate.field) = { + {::_pbi::TcParser::FastUS2, + {994, 0, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_)}}, + // string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { {::_pbi::TcParser::FastUS2, - {2042, 1, 0, - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_prefix_)}}, + {1002, 1, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.marshal_to_)}}, + // string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { + {::_pbi::TcParser::FastUS2, + {1010, 2, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.csv_columns_)}}, + // string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { + {::_pbi::TcParser::FastUS2, + {1018, 3, 0, + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.xtcp_proto_file_)}}, }}, {{ 40, 0, 13, - 62462, 3, - 49135, 6, - 65279, 8, - 61435, 9, - 65471, 11, - 2050, 12, - 48480, 26, - 65279, 34, - 4091, 35, - 65464, 40, - 58366, 44, - 8207, 48, - 61440, 59, + 50172, 15, + 64527, 21, + 61695, 27, + 4095, 31, + 61496, 35, + 33791, 44, + 16383, 49, + 65279, 51, + 65475, 52, + 65535, 56, + 58360, 56, + 49039, 62, + 39167, 66, 65535, 65535 }}, {{ // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nl_timeout_milliseconds_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nl_timeout_milliseconds_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_frequency_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { + // .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_timeout_), _Internal::kHasBitsOffset + 6, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.max_loops_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_done_chan_size_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nlmsg_seq_), _Internal::kHasBitsOffset + 12, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_mply_), _Internal::kHasBitsOffset + 13, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.write_files_), _Internal::kHasBitsOffset + 14, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.capture_path_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.marshal_to_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_rows_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_compression_), _Internal::kHasBitsOffset + 20, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_endpoint_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string s3_bucket = 126 [json_name = "s3Bucket", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_bucket_), _Internal::kHasBitsOffset + 21, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_prefix_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string s3_access_key = 128 [json_name = "s3AccessKey", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_access_key_), _Internal::kHasBitsOffset + 22, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_secret_key_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string dest = 130 [json_name = "dest", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_), _Internal::kHasBitsOffset + 23, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_region_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_url_), _Internal::kHasBitsOffset + 24, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { + // uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.max_loops_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.netlinkers_done_chan_size_), _Internal::kHasBitsOffset + 12, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.nlmsg_seq_), _Internal::kHasBitsOffset + 13, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_), _Internal::kHasBitsOffset + 14, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.packet_size_mply_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.modulus_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_), _Internal::kHasBitsOffset + 7, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // .google.protobuf.Duration reconcile_frequency = 40 [json_name = "reconcileFrequency", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_), _Internal::kHasBitsOffset + 43, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 20, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // uint32 write_files = 50 [json_name = "writeFiles", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.write_files_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string capture_path = 51 [json_name = "capturePath", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.capture_path_), _Internal::kHasBitsOffset + 23, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 dest_write_files = 52 [json_name = "destWriteFiles", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 debug_level = 53 [json_name = "debugLevel", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string dest = 60 [json_name = "dest", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.marshal_to_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.csv_columns_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.xtcp_proto_file_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 envelope_flush_threshold_bytes = 64 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_bytes_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 envelope_flush_threshold_rows = 65 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.envelope_flush_threshold_rows_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string topic = 80 [json_name = "topic", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.topic_), _Internal::kHasBitsOffset + 24, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string kafka_schema_url = 81 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_schema_url_), _Internal::kHasBitsOffset + 25, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .google.protobuf.Duration kafka_produce_timeout = 82 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_), _Internal::kHasBitsOffset + 44, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string kafka_compression = 83 [json_name = "kafkaCompression", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_compression_), _Internal::kHasBitsOffset + 26, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_endpoint = 100 [json_name = "s3Endpoint", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_endpoint_), _Internal::kHasBitsOffset + 27, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_region = 101 [json_name = "s3Region", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_region_), _Internal::kHasBitsOffset + 28, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_bucket = 102 [json_name = "s3Bucket", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_bucket_), _Internal::kHasBitsOffset + 29, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_prefix = 103 [json_name = "s3Prefix", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_prefix_), _Internal::kHasBitsOffset + 30, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_access_key = 104 [json_name = "s3AccessKey", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_access_key_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string s3_secret_key = 105 [json_name = "s3SecretKey", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_secret_key_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_), _Internal::kHasBitsOffset + 21, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // uint32 s3_parquet_flush_threshold_bytes = 110 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // .google.protobuf.Duration s3_flush_interval = 111 [json_name = "s3FlushInterval", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_interval_), _Internal::kHasBitsOffset + 45, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // uint32 s3_flush_jitter_pct = 112 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 s3_flush_threshold_jitter_pct = 113 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 s3_upload_max_attempts = 114 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // .google.protobuf.Duration s3_upload_backoff_cap = 115 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_backoff_cap_), _Internal::kHasBitsOffset + 46, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // string hostname = 130 [json_name = "hostname", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.hostname_), _Internal::kHasBitsOffset + 33, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string location = 131 [json_name = "location", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.location_), _Internal::kHasBitsOffset + 34, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string label = 132 [json_name = "label", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.label_), _Internal::kHasBitsOffset + 35, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string tag = 133 [json_name = "tag", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.tag_), _Internal::kHasBitsOffset + 36, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string daemon_version = 134 [json_name = "daemonVersion", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.daemon_version_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 ipv4_ttl = 150 [json_name = "ipv4Ttl", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 ipv6_hop_limit = 151 [json_name = "ipv6HopLimit", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 grpc_port = 160 [json_name = "grpcPort", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string pyroscope_url = 170 [json_name = "pyroscopeUrl", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_url_), _Internal::kHasBitsOffset + 38, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_app_name_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string topic = 140 [json_name = "topic", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.topic_), _Internal::kHasBitsOffset + 25, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.xtcp_proto_file_), _Internal::kHasBitsOffset + 26, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_schema_url_), _Internal::kHasBitsOffset + 27, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_), _Internal::kHasBitsOffset + 38, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.debug_level_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string label = 170 [json_name = "label", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.label_), _Internal::kHasBitsOffset + 28, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string tag = 180 [json_name = "tag", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.tag_), _Internal::kHasBitsOffset + 29, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string location = 181 [json_name = "location", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.location_), _Internal::kHasBitsOffset + 30, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.hostname_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv4_ttl_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.ipv6_hop_limit_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.daemon_version_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.grpc_port_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enabled_deserializers_), _Internal::kHasBitsOffset + 39, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_recv_batch_size_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.io_uring_cqe_batch_size_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.csv_columns_), _Internal::kHasBitsOffset + 33, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_jitter_pct_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_interval_), _Internal::kHasBitsOffset + 40, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_jitter_pct_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_max_attempts_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_upload_backoff_cap_), _Internal::kHasBitsOffset + 41, 5, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_), _Internal::kHasBitsOffset + 42, 6, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_before_poll_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; + // uint32 pyroscope_sample_hz = 172 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_sample_hz_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 pyroscope_upload_interval_sec = 173 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.pyroscope_upload_interval_sec_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // bool resolve_container_id = 200 [json_name = "resolveContainerId", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.resolve_container_id_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // bool enrich_container_enable = 201 [json_name = "enrichContainerEnable"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_container_enable_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.docker_socket_path_), _Internal::kHasBitsOffset + 34, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; + // string docker_socket_path = 202 [json_name = "dockerSocketPath", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.docker_socket_path_), _Internal::kHasBitsOffset + 39, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool enrich_lldp_enable = 210 [json_name = "enrichLldpEnable"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_lldp_enable_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_socket_path_), _Internal::kHasBitsOffset + 35, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_version_hint_), _Internal::kHasBitsOffset + 36, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; + // string lldpd_socket_path = 211 [json_name = "lldpdSocketPath", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_socket_path_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string lldpd_version_hint = 212 [json_name = "lldpdVersionHint", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.lldpd_version_hint_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // bool enrich_nic_enable = 220 [json_name = "enrichNicEnable"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_nic_enable_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_interfaces_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, - // bool populate_nsid = 238 [json_name = "populateNsid"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + // uint32 uplink_count = 221 [json_name = "uplinkCount", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_count_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // repeated string uplink_interfaces = 222 [json_name = "uplinkInterfaces", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.uplink_interfaces_), _Internal::kHasBitsOffset + 22, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, + // bool populate_nsid = 230 [json_name = "populateNsid"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.populate_nsid_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // bool enrich_asn_enable = 240 [json_name = "enrichAsnEnable"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_asn_enable_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_db_path_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_refresh_interval_), _Internal::kHasBitsOffset + 43, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + // string asn_db_path = 241 [json_name = "asnDbPath", (.buf.validate.field) = { + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_db_path_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .google.protobuf.Duration asn_refresh_interval = 242 [json_name = "asnRefreshInterval"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.asn_refresh_interval_), _Internal::kHasBitsOffset + 47, 7, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // bool enrich_locality_enable = 245 [json_name = "enrichLocalityEnable"]; {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_locality_enable_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; - {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.locality_refresh_interval_), _Internal::kHasBitsOffset + 44, 8, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .google.protobuf.Duration locality_refresh_interval = 246 [json_name = "localityRefreshInterval"]; + {PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.locality_refresh_interval_), _Internal::kHasBitsOffset + 48, 8, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ #ifndef PROTOBUF_MESSAGE_GLOBALS @@ -1784,14 +1799,14 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, #endif #ifndef PROTOBUF_MESSAGE_GLOBALS - {::_pbi::TcParser::GetTable<::google::protobuf::Duration>()}, + {::_pbi::TcParser::GetTable<::xtcp_config::v1::EnabledDeserializers>()}, #else - {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, + {::_pbi::FieldAuxMessageGlobals(), &::xtcp_config::v1::EnabledDeserializers_globals_}, #endif #ifndef PROTOBUF_MESSAGE_GLOBALS - {::_pbi::TcParser::GetTable<::xtcp_config::v1::EnabledDeserializers>()}, + {::_pbi::TcParser::GetTable<::google::protobuf::Duration>()}, #else - {::_pbi::FieldAuxMessageGlobals(), &::xtcp_config::v1::EnabledDeserializers_globals_}, + {::_pbi::FieldAuxMessageGlobals(), &::google::protobuf::Duration_globals_}, #endif #ifndef PROTOBUF_MESSAGE_GLOBALS {::_pbi::TcParser::GetTable<::google::protobuf::Duration>()}, @@ -1820,29 +1835,29 @@ constexpr XtcpConfig::ParseTableT_ XtcpConfig::InternalGenerateParseTable_(const #endif }}, {{ - "\31\0\0\0\0\0\0\0\0\0\0\14\0\12\0\0\21\13\11\11\15\15\4\0\11\0\0\15\22\0\0\5\17\20\0\0\5\3\10\10\0\0\0\16\0\0\0\0\0\13\0\0\0\0\0\0\0\0\0\22\0\21\22\0\0\21\0\0\13\0\0\0" + "\31\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\14\0\0\4\12\13\17\0\0\5\20\0\21\13\11\11\11\15\15\0\0\0\0\0\0\0\10\10\5\3\16\0\0\0\15\22\0\0\0\0\22\0\21\22\0\0\21\0\0\13\0\0\0" "xtcp_config.v1.XtcpConfig" "capture_path" + "dest" "marshal_to" + "csv_columns" + "xtcp_proto_file" + "topic" + "kafka_schema_url" "kafka_compression" "s3_endpoint" + "s3_region" "s3_bucket" "s3_prefix" "s3_access_key" "s3_secret_key" - "dest" - "s3_region" - "pyroscope_url" - "pyroscope_app_name" - "topic" - "xtcp_proto_file" - "kafka_schema_url" + "hostname" + "location" "label" "tag" - "location" - "hostname" "daemon_version" - "csv_columns" + "pyroscope_url" + "pyroscope_app_name" "docker_socket_path" "lldpd_socket_path" "lldpd_version_hint" @@ -1857,16 +1872,16 @@ inline constexpr XtcpConfig::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - s3_endpoint_( + dest_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - s3_prefix_( + marshal_to_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - s3_secret_key_( + csv_columns_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - s3_region_( + xtcp_proto_file_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), pyroscope_app_name_( @@ -1874,16 +1889,21 @@ inline constexpr XtcpConfig::Impl_::Impl_( ::_pbi::ConstantInitialized()), poll_frequency_{nullptr}, poll_timeout_{nullptr}, + enabled_deserializers_{nullptr}, nl_timeout_milliseconds_{::uint64_t{0u}}, max_loops_{::uint64_t{0u}}, + poll_jitter_pct_{0u}, netlinkers_{0u}, netlinkers_done_chan_size_{0u}, - packet_size_{::uint64_t{0u}}, nlmsg_seq_{0u}, + packet_size_{::uint64_t{0u}}, + modulus_{::uint64_t{0u}}, packet_size_mply_{0u}, - write_files_{0u}, - envelope_flush_threshold_rows_{0u}, - dest_write_files_{0u}, + io_uring_recv_batch_size_{0u}, + io_uring_cqe_batch_size_{0u}, + io_uring_{false}, + reconcile_before_poll_{false}, + s3_skip_bucket_probe_{false}, uplink_interfaces_ { visibility, ::_pbi::InternalMetadataOffset::Build< ::xtcp_config::v1::XtcpConfig, PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.uplink_interfaces_)>() @@ -1892,49 +1912,49 @@ inline constexpr XtcpConfig::Impl_::Impl_( capture_path_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - marshal_to_( + topic_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - kafka_compression_( + kafka_schema_url_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - s3_bucket_( + kafka_compression_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - s3_access_key_( + s3_endpoint_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - dest_( + s3_region_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - pyroscope_url_( + s3_bucket_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - topic_( + s3_prefix_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - xtcp_proto_file_( + s3_access_key_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - kafka_schema_url_( + s3_secret_key_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - label_( + hostname_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - tag_( + location_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - location_( + label_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - hostname_( + tag_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), daemon_version_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - csv_columns_( + pyroscope_url_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), docker_socket_path_( @@ -1949,37 +1969,32 @@ inline constexpr XtcpConfig::Impl_::Impl_( asn_db_path_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), + reconcile_frequency_{nullptr}, kafka_produce_timeout_{nullptr}, - enabled_deserializers_{nullptr}, s3_flush_interval_{nullptr}, s3_upload_backoff_cap_{nullptr}, - reconcile_frequency_{nullptr}, asn_refresh_interval_{nullptr}, locality_refresh_interval_{nullptr}, - modulus_{::uint64_t{0u}}, + write_files_{0u}, + dest_write_files_{0u}, + debug_level_{0u}, envelope_flush_threshold_bytes_{0u}, + envelope_flush_threshold_rows_{0u}, s3_parquet_flush_threshold_bytes_{0u}, - pyroscope_sample_hz_{0u}, - pyroscope_upload_interval_sec_{0u}, - debug_level_{0u}, - ipv4_ttl_{0u}, - ipv6_hop_limit_{0u}, - s3_skip_bucket_probe_{false}, - resolve_container_id_{false}, - io_uring_{false}, - reconcile_before_poll_{false}, - grpc_port_{0u}, - io_uring_recv_batch_size_{0u}, - io_uring_cqe_batch_size_{0u}, - poll_jitter_pct_{0u}, s3_flush_jitter_pct_{0u}, s3_flush_threshold_jitter_pct_{0u}, s3_upload_max_attempts_{0u}, + ipv4_ttl_{0u}, + ipv6_hop_limit_{0u}, + grpc_port_{0u}, + pyroscope_sample_hz_{0u}, + pyroscope_upload_interval_sec_{0u}, + resolve_container_id_{false}, enrich_container_enable_{false}, enrich_lldp_enable_{false}, enrich_nic_enable_{false}, - populate_nsid_{false}, uplink_count_{0u}, + populate_nsid_{false}, enrich_asn_enable_{false}, enrich_locality_enable_{false} {} @@ -3040,60 +3055,60 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.nl_timeout_milliseconds_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_frequency_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_timeout_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_jitter_pct_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.max_loops_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.netlinkers_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.netlinkers_done_chan_size_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.nlmsg_seq_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.packet_size_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.packet_size_mply_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.modulus_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enabled_deserializers_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_recv_batch_size_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_cqe_batch_size_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.reconcile_frequency_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.reconcile_before_poll_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.write_files_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.capture_path_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.modulus_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.dest_write_files_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.debug_level_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.dest_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.marshal_to_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.csv_columns_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.xtcp_proto_file_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.envelope_flush_threshold_bytes_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.envelope_flush_threshold_rows_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.topic_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.kafka_schema_url_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.kafka_produce_timeout_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.kafka_compression_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_endpoint_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_region_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_bucket_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_prefix_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_access_key_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_secret_key_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_region_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_skip_bucket_probe_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_url_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_app_name_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_sample_hz_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_upload_interval_sec_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.dest_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.dest_write_files_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.topic_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.xtcp_proto_file_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.kafka_schema_url_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.kafka_produce_timeout_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.debug_level_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_parquet_flush_threshold_bytes_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_interval_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_jitter_pct_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_upload_max_attempts_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_upload_backoff_cap_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.hostname_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.location_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.label_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.tag_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.location_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.hostname_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.daemon_version_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.resolve_container_id_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.ipv4_ttl_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.ipv6_hop_limit_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.grpc_port_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enabled_deserializers_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_recv_batch_size_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.io_uring_cqe_batch_size_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.csv_columns_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.poll_jitter_pct_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_interval_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_jitter_pct_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_flush_threshold_jitter_pct_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_upload_max_attempts_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.s3_upload_backoff_cap_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.reconcile_frequency_), - PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.reconcile_before_poll_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_url_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_app_name_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_sample_hz_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.pyroscope_upload_interval_sec_), + PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.resolve_container_id_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_container_enable_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.docker_socket_path_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_lldp_enable_), @@ -3108,77 +3123,77 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.asn_refresh_interval_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.enrich_locality_enable_), PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::XtcpConfig, _impl_.locality_refresh_interval_), - 7, + 8, 5, 6, - 8, - 9, 10, - 12, + 9, 11, + 12, 13, 14, - 18, - 45, - 19, - 46, + 16, 15, + 7, + 19, + 17, + 18, + 43, 20, + 49, + 23, + 50, + 51, 0, - 21, 1, - 22, 2, - 47, 3, + 52, 53, 24, - 4, - 48, - 49, - 23, - 16, 25, + 44, 26, 27, - 38, - 50, 28, 29, 30, 31, 32, + 21, 54, - 51, - 52, - 57, - 39, + 45, 55, + 56, + 57, + 46, + 33, + 34, + 35, + 36, + 37, 58, 59, - 33, 60, - 40, + 38, + 4, 61, 62, 63, - 41, - 42, - 56, 64, - 34, + 39, 65, - 35, - 36, + 40, + 41, 66, - 68, - 17, 67, + 22, + 68, 69, - 37, - 43, + 42, + 47, 70, - 44, + 48, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_config::v1::EnabledDeserializers_EnabledEntry_DoNotUse, _impl_._has_bits_), 5, // hasbit index offset @@ -3283,141 +3298,140 @@ const char descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto[ " 0 || this.envelope_flush_threshold_rows" " > 0\"N\n\030SetEnvelopeFlushResponse\0222\n\006conf" "ig\030\001 \001(\0132\032.xtcp_config.v1.XtcpConfigR\006co" - "nfig\"\256 \n\nXtcpConfig\022F\n\027nl_timeout_millis" + "nfig\"\225 \n\nXtcpConfig\022F\n\027nl_timeout_millis" "econds\030\n \001(\004B\016\272H\0132\006\030\240\215\006(\000\310\001\001R\025nlTimeoutM" - "illiseconds\022S\n\016poll_frequency\030\024 \001(\0132\031.go" + "illiseconds\022S\n\016poll_frequency\030\013 \001(\0132\031.go" "ogle.protobuf.DurationB\021\272H\016\252\001\010\"\004\010\200\365$*\000\310\001" - "\001R\rpollFrequency\022O\n\014poll_timeout\030\036 \001(\0132\031" + "\001R\rpollFrequency\022O\n\014poll_timeout\030\014 \001(\0132\031" ".google.protobuf.DurationB\021\272H\016\252\001\010\"\004\010\200\365$*" - "\000\310\001\001R\013pollTimeout\022+\n\tmax_loops\030( \001(\004B\016\272H" - "\0132\006\030\240\215\006(\000\310\001\000R\010maxLoops\022,\n\nnetlinkers\0302 \001" - "(\rB\014\272H\t*\004\030d(\001\310\001\001R\nnetlinkers\022H\n\031netlinke" - "rs_done_chan_size\0303 \001(\rB\r\272H\n*\005\030\350\007(\001\310\001\001R\026" - "netlinkersDoneChanSize\022*\n\tnlmsg_seq\030< \001(" - "\rB\r\272H\n*\005\030\220N(\000\310\001\001R\010nlmsgSeq\022/\n\013packet_siz" - "e\030F \001(\004B\016\272H\0132\006\030\300\204=(\000\310\001\000R\npacketSize\0226\n\020p" - "acket_size_mply\030P \001(\rB\014\272H\t*\004\030d(\000\310\001\000R\016pac" - "ketSizeMply\022.\n\013write_files\030Z \001(\rB\r\272H\n*\005\030" - "\350\007(\000\310\001\000R\nwriteFiles\022/\n\014capture_path\030d \001(" - "\tB\014\272H\tr\004\020\001\030P\310\001\000R\013capturePath\022(\n\007modulus\030" - "n \001(\004B\016\272H\0132\006\030\300\204=(\001\310\001\001R\007modulus\022+\n\nmarsha" - "l_to\030x \001(\tB\014\272H\tr\004\020\003\030(\310\001\001R\tmarshalTo\022K\n\036e" - "nvelope_flush_threshold_bytes\030z \001(\rB\006\272H\003" - "\310\001\000R\033envelopeFlushThresholdBytes\022I\n\035enve" - "lope_flush_threshold_rows\030{ \001(\rB\006\272H\003\310\001\000R" - "\032envelopeFlushThresholdRows\0223\n\021kafka_com" - "pression\030| \001(\tB\006\272H\003\310\001\000R\020kafkaCompression" - "\022\'\n\013s3_endpoint\030} \001(\tB\006\272H\003\310\001\000R\ns3Endpoin" - "t\022#\n\ts3_bucket\030~ \001(\tB\006\272H\003\310\001\000R\010s3Bucket\022#" - "\n\ts3_prefix\030\177 \001(\tB\006\272H\003\310\001\000R\010s3Prefix\022+\n\rs" - "3_access_key\030\200\001 \001(\tB\006\272H\003\310\001\000R\013s3AccessKey" - "\022+\n\rs3_secret_key\030\201\001 \001(\tB\006\272H\003\310\001\000R\013s3Secr" - "etKey\022O\n s3_parquet_flush_threshold_byte" - "s\030\204\001 \001(\rB\006\272H\003\310\001\000R\034s3ParquetFlushThreshol" - "dBytes\022$\n\ts3_region\030\205\001 \001(\tB\006\272H\003\310\001\000R\010s3Re" - "gion\0228\n\024s3_skip_bucket_probe\030\206\001 \001(\010B\006\272H\003" - "\310\001\000R\021s3SkipBucketProbe\022,\n\rpyroscope_url\030" - "\210\001 \001(\tB\006\272H\003\310\001\000R\014pyroscopeUrl\0225\n\022pyroscop" - "e_app_name\030\211\001 \001(\tB\006\272H\003\310\001\000R\020pyroscopeAppN" - "ame\0227\n\023pyroscope_sample_hz\030\212\001 \001(\rB\006\272H\003\310\001" - "\000R\021pyroscopeSampleHz\022J\n\035pyroscope_upload" - "_interval_sec\030\213\001 \001(\rB\006\272H\003\310\001\000R\032pyroscopeU" - "ploadIntervalSec\022\"\n\004dest\030\202\001 \001(\tB\r\272H\nr\005\020\004" - "\030\200\004\310\001\001R\004dest\0228\n\020dest_write_files\030\207\001 \001(\rB" - "\r\272H\n*\005\030\350\007(\000\310\001\000R\016destWriteFiles\022#\n\005topic\030" - "\214\001 \001(\tB\014\272H\tr\004\020\001\030(\310\001\000R\005topic\0225\n\017xtcp_prot" - "o_file\030\217\001 \001(\tB\014\272H\tr\004\020\001\030P\310\001\000R\rxtcpProtoFi" - "le\0227\n\020kafka_schema_url\030\221\001 \001(\tB\014\272H\tr\004\020\001\030<" - "\310\001\000R\016kafkaSchemaUrl\022`\n\025kafka_produce_tim" - "eout\030\226\001 \001(\0132\031.google.protobuf.DurationB\020" - "\272H\r\252\001\007\"\003\010\330\0042\000\310\001\000R\023kafkaProduceTimeout\022/\n" - "\013debug_level\030\240\001 \001(\rB\r\272H\n*\005\030\350\007(\000\310\001\001R\ndebu" - "gLevel\022!\n\005label\030\252\001 \001(\tB\n\272H\007r\002\030(\310\001\000R\005labe" - "l\022\035\n\003tag\030\264\001 \001(\tB\n\272H\007r\002\030(\310\001\000R\003tag\022(\n\010loca" - "tion\030\265\001 \001(\tB\013\272H\010r\003\030\375\001\310\001\000R\010location\022(\n\010ho" - "stname\030\266\001 \001(\tB\013\272H\010r\003\030\375\001\310\001\000R\010hostname\0223\n\016" - "daemon_version\030\272\001 \001(\tB\013\272H\010r\003\030\375\001\310\001\000R\rdaem" - "onVersion\0229\n\024resolve_container_id\030\267\001 \001(\010" - "B\006\272H\003\310\001\000R\022resolveContainerId\022\'\n\010ipv4_ttl" - "\030\270\001 \001(\rB\013\272H\010*\003\030\377\001\310\001\000R\007ipv4Ttl\0222\n\016ipv6_ho" - "p_limit\030\271\001 \001(\rB\013\272H\010*\003\030\377\001\310\001\000R\014ipv6HopLimi" - "t\022,\n\tgrpc_port\030\276\001 \001(\rB\016\272H\013*\006\030\377\377\003(\001\310\001\001R\010g" - "rpcPort\022b\n\025enabled_deserializers\030\310\001 \001(\0132" - "$.xtcp_config.v1.EnabledDeserializersB\006\272" - "H\003\310\001\000R\024enabledDeserializers\022\"\n\010io_uring\030" - "\322\001 \001(\010B\006\272H\003\310\001\000R\007ioUring\022F\n\030io_uring_recv" - "_batch_size\030\323\001 \001(\rB\r\272H\n*\005\030\200 (\001\310\001\000R\024ioUri" - "ngRecvBatchSize\022D\n\027io_uring_cqe_batch_si" - "ze\030\324\001 \001(\rB\r\272H\n*\005\030\200 (\001\310\001\000R\023ioUringCqeBatc" - "hSize\022(\n\013csv_columns\030\334\001 \001(\tB\006\272H\003\310\001\000R\ncsv" - "Columns\0223\n\017poll_jitter_pct\030\335\001 \001(\rB\n\272H\007*\002" - "\030d\310\001\000R\rpollJitterPct\022S\n\021s3_flush_interva" - "l\030\336\001 \001(\0132\031.google.protobuf.DurationB\013\272H\010" - "\252\001\0022\000\310\001\000R\017s3FlushInterval\022:\n\023s3_flush_ji" - "tter_pct\030\337\001 \001(\rB\n\272H\007*\002\030d\310\001\000R\020s3FlushJitt" - "erPct\022M\n\035s3_flush_threshold_jitter_pct\030\340" - "\001 \001(\rB\n\272H\007*\002\030d\310\001\000R\031s3FlushThresholdJitte" - "rPct\022B\n\026s3_upload_max_attempts\030\341\001 \001(\rB\014\272" - "H\t*\004\030d(\001\310\001\000R\023s3UploadMaxAttempts\022Z\n\025s3_u" - "pload_backoff_cap\030\342\001 \001(\0132\031.google.protob" - "uf.DurationB\013\272H\010\252\001\0022\000\310\001\000R\022s3UploadBackof" - "fCap\022X\n\023reconcile_frequency\030\343\001 \001(\0132\031.goo" - "gle.protobuf.DurationB\013\272H\010\252\001\0022\000\310\001\000R\022reco" - "ncileFrequency\0223\n\025reconcile_before_poll\030" - "\344\001 \001(\010R\023reconcileBeforePoll\0227\n\027enrich_co" - "ntainer_enable\030\346\001 \001(\010R\025enrichContainerEn" - "able\0227\n\022docker_socket_path\030\347\001 \001(\tB\010\272H\005r\003" - "\030\377\001R\020dockerSocketPath\022-\n\022enrich_lldp_ena" - "ble\030\350\001 \001(\010R\020enrichLldpEnable\0225\n\021lldpd_so" - "cket_path\030\351\001 \001(\tB\010\272H\005r\003\030\377\001R\017lldpdSocketP" - "ath\0226\n\022lldpd_version_hint\030\352\001 \001(\tB\007\272H\004r\002\030" - "\020R\020lldpdVersionHint\022+\n\021enrich_nic_enable" - "\030\353\001 \001(\010R\017enrichNicEnable\022+\n\014uplink_count" - "\030\354\001 \001(\rB\007\272H\004*\002\030\002R\013uplinkCount\0226\n\021uplink_" - "interfaces\030\355\001 \003(\tB\010\272H\005\222\001\002\020\002R\020uplinkInter" - "faces\022$\n\rpopulate_nsid\030\356\001 \001(\010R\014populateN" - "sid\022+\n\021enrich_asn_enable\030\357\001 \001(\010R\017enrichA" - "snEnable\022)\n\013asn_db_path\030\360\001 \001(\tB\010\272H\005r\003\030\377\001" - "R\tasnDbPath\022L\n\024asn_refresh_interval\030\361\001 \001" - "(\0132\031.google.protobuf.DurationR\022asnRefres" - "hInterval\0225\n\026enrich_locality_enable\030\362\001 \001" - "(\010R\024enrichLocalityEnable\022V\n\031locality_ref" - "resh_interval\030\363\001 \001(\0132\031.google.protobuf.D" - "urationR\027localityRefreshInterval:s\272Hp\032n\n" - "\017XtcpConfig.poll\0222Poll timeout must be l" - "ess than poll poll_frequency\032\'this.poll_" - "frequency > this.poll_timeout\"\237\001\n\024Enable" - "dDeserializers\022K\n\007enabled\030\001 \003(\01321.xtcp_c" - "onfig.v1.EnabledDeserializers.EnabledEnt" - "ryR\007enabled\032:\n\014EnabledEntry\022\020\n\003key\030\001 \001(\t" - "R\003key\022\024\n\005value\030\002 \001(\010R\005value:\0028\0012\207\007\n\rConf" - "igService\022]\n\003Get\022\032.xtcp_config.v1.GetReq" - "uest\032\033.xtcp_config.v1.GetResponse\"\035\202\323\344\223\002" - "\027\032\022/ConfigService/Get:\001*\022]\n\003Set\022\032.xtcp_c" - "onfig.v1.SetRequest\032\033.xtcp_config.v1.Set" - "Response\"\035\202\323\344\223\002\027\032\022/ConfigService/Set:\001*\022" - "\221\001\n\020SetPollFrequency\022\'.xtcp_config.v1.Se" - "tPollFrequencyRequest\032(.xtcp_config.v1.S" - "etPollFrequencyResponse\"*\202\323\344\223\002$\032\037/Config" - "Service/SetPollFrequency:\001*\022}\n\013TriggerPo" - "ll\022\".xtcp_config.v1.TriggerPollRequest\032#" - ".xtcp_config.v1.TriggerPollResponse\"%\202\323\344" - "\223\002\037\032\032/ConfigService/TriggerPoll:\001*\022\221\001\n\020T" - "riggerPollBurst\022\'.xtcp_config.v1.Trigger" - "PollBurstRequest\032(.xtcp_config.v1.Trigge" - "rPollBurstResponse\"*\202\323\344\223\002$\032\037/ConfigServi" - "ce/TriggerPollBurst:\001*\022}\n\013SetS3Upload\022\"." - "xtcp_config.v1.SetS3UploadRequest\032#.xtcp" - "_config.v1.SetS3UploadResponse\"%\202\323\344\223\002\037\032\032" - "/ConfigService/SetS3Upload:\001*\022\221\001\n\020SetEnv" - "elopeFlush\022\'.xtcp_config.v1.SetEnvelopeF" - "lushRequest\032(.xtcp_config.v1.SetEnvelope" - "FlushResponse\"*\202\323\344\223\002$\032\037/ConfigService/Se" - "tEnvelopeFlush:\001*B\220\001\n\022com.xtcp_config.v1" - "B\017XtcpConfigProtoP\001Z\024./gen/go/xtcp_confi" - "g\242\002\003XXX\252\002\rXtcpConfig.V1\312\002\rXtcpConfig\\V1\342" - "\002\031XtcpConfig\\V1\\GPBMetadata\352\002\016XtcpConfig" - "::V1b\006proto3" + "\000\310\001\001R\013pollTimeout\0222\n\017poll_jitter_pct\030\r \001" + "(\rB\n\272H\007*\002\030d\310\001\000R\rpollJitterPct\022+\n\tmax_loo" + "ps\030\016 \001(\004B\016\272H\0132\006\030\240\215\006(\000\310\001\000R\010maxLoops\022,\n\nne" + "tlinkers\030\017 \001(\rB\014\272H\t*\004\030d(\001\310\001\001R\nnetlinkers" + "\022H\n\031netlinkers_done_chan_size\030\020 \001(\rB\r\272H\n" + "*\005\030\350\007(\001\310\001\001R\026netlinkersDoneChanSize\022*\n\tnl" + "msg_seq\030\021 \001(\rB\r\272H\n*\005\030\220N(\000\310\001\001R\010nlmsgSeq\022/" + "\n\013packet_size\030\022 \001(\004B\016\272H\0132\006\030\300\204=(\000\310\001\000R\npac" + "ketSize\0226\n\020packet_size_mply\030\023 \001(\rB\014\272H\t*\004" + "\030d(\000\310\001\000R\016packetSizeMply\022(\n\007modulus\030\024 \001(\004" + "B\016\272H\0132\006\030\300\204=(\001\310\001\001R\007modulus\022a\n\025enabled_des" + "erializers\030\025 \001(\0132$.xtcp_config.v1.Enable" + "dDeserializersB\006\272H\003\310\001\000R\024enabledDeseriali" + "zers\022!\n\010io_uring\030\026 \001(\010B\006\272H\003\310\001\000R\007ioUring\022" + "E\n\030io_uring_recv_batch_size\030\027 \001(\rB\r\272H\n*\005" + "\030\200 (\001\310\001\000R\024ioUringRecvBatchSize\022C\n\027io_uri" + "ng_cqe_batch_size\030\030 \001(\rB\r\272H\n*\005\030\200 (\001\310\001\000R\023" + "ioUringCqeBatchSize\022W\n\023reconcile_frequen" + "cy\030( \001(\0132\031.google.protobuf.DurationB\013\272H\010" + "\252\001\0022\000\310\001\000R\022reconcileFrequency\0222\n\025reconcil" + "e_before_poll\030) \001(\010R\023reconcileBeforePoll" + "\022.\n\013write_files\0302 \001(\rB\r\272H\n*\005\030\350\007(\000\310\001\000R\nwr" + "iteFiles\022/\n\014capture_path\0303 \001(\tB\014\272H\tr\004\020\001\030" + "P\310\001\000R\013capturePath\0227\n\020dest_write_files\0304 " + "\001(\rB\r\272H\n*\005\030\350\007(\000\310\001\000R\016destWriteFiles\022.\n\013de" + "bug_level\0305 \001(\rB\r\272H\n*\005\030\350\007(\000\310\001\001R\ndebugLev" + "el\022!\n\004dest\030< \001(\tB\r\272H\nr\005\020\004\030\200\004\310\001\001R\004dest\022+\n" + "\nmarshal_to\030= \001(\tB\014\272H\tr\004\020\003\030(\310\001\001R\tmarshal" + "To\022\'\n\013csv_columns\030> \001(\tB\006\272H\003\310\001\000R\ncsvColu" + "mns\0224\n\017xtcp_proto_file\030\? \001(\tB\014\272H\tr\004\020\001\030P\310" + "\001\000R\rxtcpProtoFile\022K\n\036envelope_flush_thre" + "shold_bytes\030@ \001(\rB\006\272H\003\310\001\000R\033envelopeFlush" + "ThresholdBytes\022I\n\035envelope_flush_thresho" + "ld_rows\030A \001(\rB\006\272H\003\310\001\000R\032envelopeFlushThre" + "sholdRows\022\"\n\005topic\030P \001(\tB\014\272H\tr\004\020\001\030(\310\001\000R\005" + "topic\0226\n\020kafka_schema_url\030Q \001(\tB\014\272H\tr\004\020\001" + "\030<\310\001\000R\016kafkaSchemaUrl\022_\n\025kafka_produce_t" + "imeout\030R \001(\0132\031.google.protobuf.DurationB" + "\020\272H\r\252\001\007\"\003\010\330\0042\000\310\001\000R\023kafkaProduceTimeout\0223" + "\n\021kafka_compression\030S \001(\tB\006\272H\003\310\001\000R\020kafka" + "Compression\022\'\n\013s3_endpoint\030d \001(\tB\006\272H\003\310\001\000" + "R\ns3Endpoint\022#\n\ts3_region\030e \001(\tB\006\272H\003\310\001\000R" + "\010s3Region\022#\n\ts3_bucket\030f \001(\tB\006\272H\003\310\001\000R\010s3" + "Bucket\022#\n\ts3_prefix\030g \001(\tB\006\272H\003\310\001\000R\010s3Pre" + "fix\022*\n\rs3_access_key\030h \001(\tB\006\272H\003\310\001\000R\013s3Ac" + "cessKey\022*\n\rs3_secret_key\030i \001(\tB\006\272H\003\310\001\000R\013" + "s3SecretKey\0227\n\024s3_skip_bucket_probe\030j \001(" + "\010B\006\272H\003\310\001\000R\021s3SkipBucketProbe\022N\n s3_parqu" + "et_flush_threshold_bytes\030n \001(\rB\006\272H\003\310\001\000R\034" + "s3ParquetFlushThresholdBytes\022R\n\021s3_flush" + "_interval\030o \001(\0132\031.google.protobuf.Durati" + "onB\013\272H\010\252\001\0022\000\310\001\000R\017s3FlushInterval\0229\n\023s3_f" + "lush_jitter_pct\030p \001(\rB\n\272H\007*\002\030d\310\001\000R\020s3Flu" + "shJitterPct\022L\n\035s3_flush_threshold_jitter" + "_pct\030q \001(\rB\n\272H\007*\002\030d\310\001\000R\031s3FlushThreshold" + "JitterPct\022A\n\026s3_upload_max_attempts\030r \001(" + "\rB\014\272H\t*\004\030d(\001\310\001\000R\023s3UploadMaxAttempts\022Y\n\025" + "s3_upload_backoff_cap\030s \001(\0132\031.google.pro" + "tobuf.DurationB\013\272H\010\252\001\0022\000\310\001\000R\022s3UploadBac" + "koffCap\022(\n\010hostname\030\202\001 \001(\tB\013\272H\010r\003\030\375\001\310\001\000R" + "\010hostname\022(\n\010location\030\203\001 \001(\tB\013\272H\010r\003\030\375\001\310\001" + "\000R\010location\022!\n\005label\030\204\001 \001(\tB\n\272H\007r\002\030(\310\001\000R" + "\005label\022\035\n\003tag\030\205\001 \001(\tB\n\272H\007r\002\030(\310\001\000R\003tag\0223\n" + "\016daemon_version\030\206\001 \001(\tB\013\272H\010r\003\030\375\001\310\001\000R\rdae" + "monVersion\022\'\n\010ipv4_ttl\030\226\001 \001(\rB\013\272H\010*\003\030\377\001\310" + "\001\000R\007ipv4Ttl\0222\n\016ipv6_hop_limit\030\227\001 \001(\rB\013\272H" + "\010*\003\030\377\001\310\001\000R\014ipv6HopLimit\022,\n\tgrpc_port\030\240\001 " + "\001(\rB\016\272H\013*\006\030\377\377\003(\001\310\001\001R\010grpcPort\022,\n\rpyrosco" + "pe_url\030\252\001 \001(\tB\006\272H\003\310\001\000R\014pyroscopeUrl\0225\n\022p" + "yroscope_app_name\030\253\001 \001(\tB\006\272H\003\310\001\000R\020pyrosc" + "opeAppName\0227\n\023pyroscope_sample_hz\030\254\001 \001(\r" + "B\006\272H\003\310\001\000R\021pyroscopeSampleHz\022J\n\035pyroscope" + "_upload_interval_sec\030\255\001 \001(\rB\006\272H\003\310\001\000R\032pyr" + "oscopeUploadIntervalSec\0229\n\024resolve_conta" + "iner_id\030\310\001 \001(\010B\006\272H\003\310\001\000R\022resolveContainer" + "Id\0227\n\027enrich_container_enable\030\311\001 \001(\010R\025en" + "richContainerEnable\0227\n\022docker_socket_pat" + "h\030\312\001 \001(\tB\010\272H\005r\003\030\377\001R\020dockerSocketPath\022-\n\022" + "enrich_lldp_enable\030\322\001 \001(\010R\020enrichLldpEna" + "ble\0225\n\021lldpd_socket_path\030\323\001 \001(\tB\010\272H\005r\003\030\377" + "\001R\017lldpdSocketPath\0226\n\022lldpd_version_hint" + "\030\324\001 \001(\tB\007\272H\004r\002\030\020R\020lldpdVersionHint\022+\n\021en" + "rich_nic_enable\030\334\001 \001(\010R\017enrichNicEnable\022" + "+\n\014uplink_count\030\335\001 \001(\rB\007\272H\004*\002\030\002R\013uplinkC" + "ount\0226\n\021uplink_interfaces\030\336\001 \003(\tB\010\272H\005\222\001\002" + "\020\002R\020uplinkInterfaces\022$\n\rpopulate_nsid\030\346\001" + " \001(\010R\014populateNsid\022+\n\021enrich_asn_enable\030" + "\360\001 \001(\010R\017enrichAsnEnable\022)\n\013asn_db_path\030\361" + "\001 \001(\tB\010\272H\005r\003\030\377\001R\tasnDbPath\022L\n\024asn_refres" + "h_interval\030\362\001 \001(\0132\031.google.protobuf.Dura" + "tionR\022asnRefreshInterval\0225\n\026enrich_local" + "ity_enable\030\365\001 \001(\010R\024enrichLocalityEnable\022" + "V\n\031locality_refresh_interval\030\366\001 \001(\0132\031.go" + "ogle.protobuf.DurationR\027localityRefreshI" + "nterval:s\272Hp\032n\n\017XtcpConfig.poll\0222Poll ti" + "meout must be less than poll poll_freque" + "ncy\032\'this.poll_frequency > this.poll_tim" + "eout\"\237\001\n\024EnabledDeserializers\022K\n\007enabled" + "\030\001 \003(\01321.xtcp_config.v1.EnabledDeseriali" + "zers.EnabledEntryR\007enabled\032:\n\014EnabledEnt" + "ry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n\005value\030\002 \001(\010R\005val" + "ue:\0028\0012\207\007\n\rConfigService\022]\n\003Get\022\032.xtcp_c" + "onfig.v1.GetRequest\032\033.xtcp_config.v1.Get" + "Response\"\035\202\323\344\223\002\027\032\022/ConfigService/Get:\001*\022" + "]\n\003Set\022\032.xtcp_config.v1.SetRequest\032\033.xtc" + "p_config.v1.SetResponse\"\035\202\323\344\223\002\027\032\022/Config" + "Service/Set:\001*\022\221\001\n\020SetPollFrequency\022\'.xt" + "cp_config.v1.SetPollFrequencyRequest\032(.x" + "tcp_config.v1.SetPollFrequencyResponse\"*" + "\202\323\344\223\002$\032\037/ConfigService/SetPollFrequency:" + "\001*\022}\n\013TriggerPoll\022\".xtcp_config.v1.Trigg" + "erPollRequest\032#.xtcp_config.v1.TriggerPo" + "llResponse\"%\202\323\344\223\002\037\032\032/ConfigService/Trigg" + "erPoll:\001*\022\221\001\n\020TriggerPollBurst\022\'.xtcp_co" + "nfig.v1.TriggerPollBurstRequest\032(.xtcp_c" + "onfig.v1.TriggerPollBurstResponse\"*\202\323\344\223\002" + "$\032\037/ConfigService/TriggerPollBurst:\001*\022}\n" + "\013SetS3Upload\022\".xtcp_config.v1.SetS3Uploa" + "dRequest\032#.xtcp_config.v1.SetS3UploadRes" + "ponse\"%\202\323\344\223\002\037\032\032/ConfigService/SetS3Uploa" + "d:\001*\022\221\001\n\020SetEnvelopeFlush\022\'.xtcp_config." + "v1.SetEnvelopeFlushRequest\032(.xtcp_config" + ".v1.SetEnvelopeFlushResponse\"*\202\323\344\223\002$\032\037/C" + "onfigService/SetEnvelopeFlush:\001*B\220\001\n\022com" + ".xtcp_config.v1B\017XtcpConfigProtoP\001Z\024./ge" + "n/go/xtcp_config\242\002\003XXX\252\002\rXtcpConfig.V1\312\002" + "\rXtcpConfig\\V1\342\002\031XtcpConfig\\V1\\GPBMetada" + "ta\352\002\016XtcpConfig::V1b\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_deps[3] = { @@ -3429,7 +3443,7 @@ static ::absl::once_flag descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2ep PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto = { false, false, - 7292, + 7267, descriptor_table_protodef_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto, "xtcp_config/v1/xtcp_config.proto", &descriptor_table_xtcp_5fconfig_2fv1_2fxtcp_5fconfig_2eproto_once, @@ -6159,35 +6173,35 @@ void XtcpConfig::clear_poll_timeout() { if (_impl_.poll_timeout_ != nullptr) _impl_.poll_timeout_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000040U); } +void XtcpConfig::clear_reconcile_frequency() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.reconcile_frequency_ != nullptr) _impl_.reconcile_frequency_->Clear(); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); +} void XtcpConfig::clear_kafka_produce_timeout() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.kafka_produce_timeout_ != nullptr) _impl_.kafka_produce_timeout_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); } void XtcpConfig::clear_s3_flush_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.s3_flush_interval_ != nullptr) _impl_.s3_flush_interval_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); } void XtcpConfig::clear_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.s3_upload_backoff_cap_ != nullptr) _impl_.s3_upload_backoff_cap_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); -} -void XtcpConfig::clear_reconcile_frequency() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.reconcile_frequency_ != nullptr) _impl_.reconcile_frequency_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } void XtcpConfig::clear_asn_refresh_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.asn_refresh_interval_ != nullptr) _impl_.asn_refresh_interval_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } void XtcpConfig::clear_locality_refresh_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.locality_refresh_interval_ != nullptr) _impl_.locality_refresh_interval_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } XtcpConfig::XtcpConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) @@ -6204,10 +6218,10 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( [[maybe_unused]] const ::xtcp_config::v1::XtcpConfig& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - s3_endpoint_(arena, from.s3_endpoint_), - s3_prefix_(arena, from.s3_prefix_), - s3_secret_key_(arena, from.s3_secret_key_), - s3_region_(arena, from.s3_region_), + dest_(arena, from.dest_), + marshal_to_(arena, from.marshal_to_), + csv_columns_(arena, from.csv_columns_), + xtcp_proto_file_(arena, from.xtcp_proto_file_), pyroscope_app_name_(arena, from.pyroscope_app_name_), uplink_interfaces_ { visibility, ::_pbi::InternalMetadataOffset::Build< @@ -6217,21 +6231,21 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( } , capture_path_(arena, from.capture_path_), - marshal_to_(arena, from.marshal_to_), + topic_(arena, from.topic_), + kafka_schema_url_(arena, from.kafka_schema_url_), kafka_compression_(arena, from.kafka_compression_), + s3_endpoint_(arena, from.s3_endpoint_), + s3_region_(arena, from.s3_region_), s3_bucket_(arena, from.s3_bucket_), + s3_prefix_(arena, from.s3_prefix_), s3_access_key_(arena, from.s3_access_key_), - dest_(arena, from.dest_), - pyroscope_url_(arena, from.pyroscope_url_), - topic_(arena, from.topic_), - xtcp_proto_file_(arena, from.xtcp_proto_file_), - kafka_schema_url_(arena, from.kafka_schema_url_), + s3_secret_key_(arena, from.s3_secret_key_), + hostname_(arena, from.hostname_), + location_(arena, from.location_), label_(arena, from.label_), tag_(arena, from.tag_), - location_(arena, from.location_), - hostname_(arena, from.hostname_), daemon_version_(arena, from.daemon_version_), - csv_columns_(arena, from.csv_columns_), + pyroscope_url_(arena, from.pyroscope_url_), docker_socket_path_(arena, from.docker_socket_path_), lldpd_socket_path_(arena, from.lldpd_socket_path_), lldpd_version_hint_(arena, from.lldpd_version_hint_), @@ -6258,41 +6272,41 @@ XtcpConfig::XtcpConfig( _impl_.poll_timeout_ = (CheckHasBit(cached_has_bits, 0x00000040U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.poll_timeout_) : nullptr; + _impl_.enabled_deserializers_ = (CheckHasBit(cached_has_bits, 0x00000080U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_) + : nullptr; ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, nl_timeout_milliseconds_), reinterpret_cast(&from._impl_) + offsetof(Impl_, nl_timeout_milliseconds_), - offsetof(Impl_, dest_write_files_) - + offsetof(Impl_, s3_skip_bucket_probe_) - offsetof(Impl_, nl_timeout_milliseconds_) + - sizeof(Impl_::dest_write_files_)); + sizeof(Impl_::s3_skip_bucket_probe_)); cached_has_bits = _impl_._has_bits_[1]; - _impl_.kafka_produce_timeout_ = (CheckHasBit(cached_has_bits, 0x00000040U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kafka_produce_timeout_) + _impl_.reconcile_frequency_ = (CheckHasBit(cached_has_bits, 0x00000800U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_) : nullptr; - _impl_.enabled_deserializers_ = (CheckHasBit(cached_has_bits, 0x00000080U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_) + _impl_.kafka_produce_timeout_ = (CheckHasBit(cached_has_bits, 0x00001000U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kafka_produce_timeout_) : nullptr; - _impl_.s3_flush_interval_ = (CheckHasBit(cached_has_bits, 0x00000100U)) + _impl_.s3_flush_interval_ = (CheckHasBit(cached_has_bits, 0x00002000U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_flush_interval_) : nullptr; - _impl_.s3_upload_backoff_cap_ = (CheckHasBit(cached_has_bits, 0x00000200U)) + _impl_.s3_upload_backoff_cap_ = (CheckHasBit(cached_has_bits, 0x00004000U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_upload_backoff_cap_) : nullptr; - _impl_.reconcile_frequency_ = (CheckHasBit(cached_has_bits, 0x00000400U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_) - : nullptr; - _impl_.asn_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00000800U)) + _impl_.asn_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00008000U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.asn_refresh_interval_) : nullptr; - _impl_.locality_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00001000U)) + _impl_.locality_refresh_interval_ = (CheckHasBit(cached_has_bits, 0x00010000U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.locality_refresh_interval_) : nullptr; ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, modulus_), + offsetof(Impl_, write_files_), reinterpret_cast(&from._impl_) + - offsetof(Impl_, modulus_), + offsetof(Impl_, write_files_), offsetof(Impl_, enrich_locality_enable_) - - offsetof(Impl_, modulus_) + + offsetof(Impl_, write_files_) + sizeof(Impl_::enrich_locality_enable_)); // @@protoc_insertion_point(copy_constructor:xtcp_config.v1.XtcpConfig) @@ -6301,10 +6315,10 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - s3_endpoint_(arena), - s3_prefix_(arena), - s3_secret_key_(arena), - s3_region_(arena), + dest_(arena), + marshal_to_(arena), + csv_columns_(arena), + xtcp_proto_file_(arena), pyroscope_app_name_(arena), uplink_interfaces_ { visibility, ::_pbi::InternalMetadataOffset::Build< ::xtcp_config::v1::XtcpConfig, @@ -6312,21 +6326,21 @@ PROTOBUF_NDEBUG_INLINE XtcpConfig::Impl_::Impl_( } , capture_path_(arena), - marshal_to_(arena), + topic_(arena), + kafka_schema_url_(arena), kafka_compression_(arena), + s3_endpoint_(arena), + s3_region_(arena), s3_bucket_(arena), + s3_prefix_(arena), s3_access_key_(arena), - dest_(arena), - pyroscope_url_(arena), - topic_(arena), - xtcp_proto_file_(arena), - kafka_schema_url_(arena), + s3_secret_key_(arena), + hostname_(arena), + location_(arena), label_(arena), tag_(arena), - location_(arena), - hostname_(arena), daemon_version_(arena), - csv_columns_(arena), + pyroscope_url_(arena), docker_socket_path_(arena), lldpd_socket_path_(arena), lldpd_version_hint_(arena), @@ -6337,14 +6351,14 @@ inline void XtcpConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, poll_frequency_), 0, - offsetof(Impl_, dest_write_files_) - + offsetof(Impl_, s3_skip_bucket_probe_) - offsetof(Impl_, poll_frequency_) + - sizeof(Impl_::dest_write_files_)); + sizeof(Impl_::s3_skip_bucket_probe_)); ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, kafka_produce_timeout_), + offsetof(Impl_, reconcile_frequency_), 0, offsetof(Impl_, enrich_locality_enable_) - - offsetof(Impl_, kafka_produce_timeout_) + + offsetof(Impl_, reconcile_frequency_) + sizeof(Impl_::enrich_locality_enable_)); } XtcpConfig::~XtcpConfig() { @@ -6358,38 +6372,38 @@ inline void XtcpConfig::SharedDtor(MessageLite& self) { } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.s3_endpoint_.Destroy(); - this_._impl_.s3_prefix_.Destroy(); - this_._impl_.s3_secret_key_.Destroy(); - this_._impl_.s3_region_.Destroy(); + this_._impl_.dest_.Destroy(); + this_._impl_.marshal_to_.Destroy(); + this_._impl_.csv_columns_.Destroy(); + this_._impl_.xtcp_proto_file_.Destroy(); this_._impl_.pyroscope_app_name_.Destroy(); delete this_._impl_.poll_frequency_; delete this_._impl_.poll_timeout_; + delete this_._impl_.enabled_deserializers_; this_._impl_.capture_path_.Destroy(); - this_._impl_.marshal_to_.Destroy(); + this_._impl_.topic_.Destroy(); + this_._impl_.kafka_schema_url_.Destroy(); this_._impl_.kafka_compression_.Destroy(); + this_._impl_.s3_endpoint_.Destroy(); + this_._impl_.s3_region_.Destroy(); this_._impl_.s3_bucket_.Destroy(); + this_._impl_.s3_prefix_.Destroy(); this_._impl_.s3_access_key_.Destroy(); - this_._impl_.dest_.Destroy(); - this_._impl_.pyroscope_url_.Destroy(); - this_._impl_.topic_.Destroy(); - this_._impl_.xtcp_proto_file_.Destroy(); - this_._impl_.kafka_schema_url_.Destroy(); + this_._impl_.s3_secret_key_.Destroy(); + this_._impl_.hostname_.Destroy(); + this_._impl_.location_.Destroy(); this_._impl_.label_.Destroy(); this_._impl_.tag_.Destroy(); - this_._impl_.location_.Destroy(); - this_._impl_.hostname_.Destroy(); this_._impl_.daemon_version_.Destroy(); - this_._impl_.csv_columns_.Destroy(); + this_._impl_.pyroscope_url_.Destroy(); this_._impl_.docker_socket_path_.Destroy(); this_._impl_.lldpd_socket_path_.Destroy(); this_._impl_.lldpd_version_hint_.Destroy(); this_._impl_.asn_db_path_.Destroy(); + delete this_._impl_.reconcile_frequency_; delete this_._impl_.kafka_produce_timeout_; - delete this_._impl_.enabled_deserializers_; delete this_._impl_.s3_flush_interval_; delete this_._impl_.s3_upload_backoff_cap_; - delete this_._impl_.reconcile_frequency_; delete this_._impl_.asn_refresh_interval_; delete this_._impl_.locality_refresh_interval_; this_._impl_.~Impl_(); @@ -6429,18 +6443,18 @@ PROTOBUF_NOINLINE void XtcpConfig::Clear() { (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.s3_endpoint_.ClearNonDefaultToEmpty(); + _impl_.dest_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.s3_prefix_.ClearNonDefaultToEmpty(); + _impl_.marshal_to_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _impl_.s3_secret_key_.ClearNonDefaultToEmpty(); + _impl_.csv_columns_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000008U)) { - _impl_.s3_region_.ClearNonDefaultToEmpty(); + _impl_.xtcp_proto_file_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000010U)) { _impl_.pyroscope_app_name_.ClearNonDefaultToEmpty(); @@ -6453,128 +6467,124 @@ PROTOBUF_NOINLINE void XtcpConfig::Clear() { ABSL_DCHECK(_impl_.poll_timeout_ != nullptr); _impl_.poll_timeout_->Clear(); } + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + ABSL_DCHECK(_impl_.enabled_deserializers_ != nullptr); + _impl_.enabled_deserializers_->Clear(); + } } - _impl_.nl_timeout_milliseconds_ = ::uint64_t{0u}; if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.max_loops_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.envelope_flush_threshold_rows_) - - reinterpret_cast(&_impl_.max_loops_)) + sizeof(_impl_.envelope_flush_threshold_rows_)); + ::memset(&_impl_.nl_timeout_milliseconds_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.modulus_) - + reinterpret_cast(&_impl_.nl_timeout_milliseconds_)) + sizeof(_impl_.modulus_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - _impl_.dest_write_files_ = 0u; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { - _impl_.uplink_interfaces_.Clear(); - } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { - _impl_.capture_path_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { - _impl_.marshal_to_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { - _impl_.kafka_compression_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { - _impl_.s3_bucket_.ClearNonDefaultToEmpty(); - } + ::memset(&_impl_.packet_size_mply_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.s3_skip_bucket_probe_) - + reinterpret_cast(&_impl_.packet_size_mply_)) + sizeof(_impl_.s3_skip_bucket_probe_)); if (CheckHasBit(cached_has_bits, 0x00400000U)) { - _impl_.s3_access_key_.ClearNonDefaultToEmpty(); + _impl_.uplink_interfaces_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00800000U)) { - _impl_.dest_.ClearNonDefaultToEmpty(); + _impl_.capture_path_.ClearNonDefaultToEmpty(); } } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { if (CheckHasBit(cached_has_bits, 0x01000000U)) { - _impl_.pyroscope_url_.ClearNonDefaultToEmpty(); + _impl_.topic_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x02000000U)) { - _impl_.topic_.ClearNonDefaultToEmpty(); + _impl_.kafka_schema_url_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x04000000U)) { - _impl_.xtcp_proto_file_.ClearNonDefaultToEmpty(); + _impl_.kafka_compression_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x08000000U)) { - _impl_.kafka_schema_url_.ClearNonDefaultToEmpty(); + _impl_.s3_endpoint_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x10000000U)) { - _impl_.label_.ClearNonDefaultToEmpty(); + _impl_.s3_region_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x20000000U)) { - _impl_.tag_.ClearNonDefaultToEmpty(); + _impl_.s3_bucket_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x40000000U)) { - _impl_.location_.ClearNonDefaultToEmpty(); + _impl_.s3_prefix_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x80000000U)) { - _impl_.hostname_.ClearNonDefaultToEmpty(); + _impl_.s3_access_key_.ClearNonDefaultToEmpty(); } } cached_has_bits = _impl_._has_bits_[1]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.daemon_version_.ClearNonDefaultToEmpty(); + _impl_.s3_secret_key_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.csv_columns_.ClearNonDefaultToEmpty(); + _impl_.hostname_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _impl_.docker_socket_path_.ClearNonDefaultToEmpty(); + _impl_.location_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000008U)) { - _impl_.lldpd_socket_path_.ClearNonDefaultToEmpty(); + _impl_.label_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000010U)) { - _impl_.lldpd_version_hint_.ClearNonDefaultToEmpty(); + _impl_.tag_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000020U)) { - _impl_.asn_db_path_.ClearNonDefaultToEmpty(); + _impl_.daemon_version_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000040U)) { - ABSL_DCHECK(_impl_.kafka_produce_timeout_ != nullptr); - _impl_.kafka_produce_timeout_->Clear(); + _impl_.pyroscope_url_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000080U)) { - ABSL_DCHECK(_impl_.enabled_deserializers_ != nullptr); - _impl_.enabled_deserializers_->Clear(); + _impl_.docker_socket_path_.ClearNonDefaultToEmpty(); } } - if (BatchCheckHasBit(cached_has_bits, 0x00001f00U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - ABSL_DCHECK(_impl_.s3_flush_interval_ != nullptr); - _impl_.s3_flush_interval_->Clear(); + _impl_.lldpd_socket_path_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000200U)) { - ABSL_DCHECK(_impl_.s3_upload_backoff_cap_ != nullptr); - _impl_.s3_upload_backoff_cap_->Clear(); + _impl_.lldpd_version_hint_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000400U)) { + _impl_.asn_db_path_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000800U)) { ABSL_DCHECK(_impl_.reconcile_frequency_ != nullptr); _impl_.reconcile_frequency_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + ABSL_DCHECK(_impl_.kafka_produce_timeout_ != nullptr); + _impl_.kafka_produce_timeout_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + ABSL_DCHECK(_impl_.s3_flush_interval_ != nullptr); + _impl_.s3_flush_interval_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00004000U)) { + ABSL_DCHECK(_impl_.s3_upload_backoff_cap_ != nullptr); + _impl_.s3_upload_backoff_cap_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00008000U)) { ABSL_DCHECK(_impl_.asn_refresh_interval_ != nullptr); _impl_.asn_refresh_interval_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - ABSL_DCHECK(_impl_.locality_refresh_interval_ != nullptr); - _impl_.locality_refresh_interval_->Clear(); - } } - if (BatchCheckHasBit(cached_has_bits, 0x0000e000U)) { - ::memset(&_impl_.modulus_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.s3_parquet_flush_threshold_bytes_) - - reinterpret_cast(&_impl_.modulus_)) + sizeof(_impl_.s3_parquet_flush_threshold_bytes_)); + if (CheckHasBit(cached_has_bits, 0x00010000U)) { + ABSL_DCHECK(_impl_.locality_refresh_interval_ != nullptr); + _impl_.locality_refresh_interval_->Clear(); } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.pyroscope_sample_hz_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.io_uring_) - - reinterpret_cast(&_impl_.pyroscope_sample_hz_)) + sizeof(_impl_.io_uring_)); + if (BatchCheckHasBit(cached_has_bits, 0x00fe0000U)) { + ::memset(&_impl_.write_files_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.s3_flush_jitter_pct_) - + reinterpret_cast(&_impl_.write_files_)) + sizeof(_impl_.s3_flush_jitter_pct_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.reconcile_before_poll_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.s3_upload_max_attempts_) - - reinterpret_cast(&_impl_.reconcile_before_poll_)) + sizeof(_impl_.s3_upload_max_attempts_)); + ::memset(&_impl_.s3_flush_threshold_jitter_pct_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.resolve_container_id_) - + reinterpret_cast(&_impl_.s3_flush_threshold_jitter_pct_)) + sizeof(_impl_.resolve_container_id_)); } cached_has_bits = _impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { @@ -6606,7 +6616,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[0]; // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_nl_timeout_milliseconds() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -6614,664 +6624,666 @@ ::uint8_t* PROTOBUF_NONNULL XtcpConfig::_InternalSerialize( } } - // .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { + // .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000020U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 20, *this_._impl_.poll_frequency_, this_._impl_.poll_frequency_->GetCachedSize(), target, + 11, *this_._impl_.poll_frequency_, this_._impl_.poll_frequency_->GetCachedSize(), target, stream); } - // .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { + // .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000040U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 30, *this_._impl_.poll_timeout_, this_._impl_.poll_timeout_->GetCachedSize(), target, + 12, *this_._impl_.poll_timeout_, this_._impl_.poll_timeout_->GetCachedSize(), target, stream); } - // uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + // uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (this_._internal_poll_jitter_pct() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 13, this_._internal_poll_jitter_pct(), target); + } + } + + // uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_max_loops() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 40, this_._internal_max_loops(), target); + 14, this_._internal_max_loops(), target); } } - // uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + // uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_netlinkers() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 50, this_._internal_netlinkers(), target); + 15, this_._internal_netlinkers(), target); } } - // uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + // uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_netlinkers_done_chan_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 51, this_._internal_netlinkers_done_chan_size(), target); + 16, this_._internal_netlinkers_done_chan_size(), target); } } - // uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + // uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_nlmsg_seq() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 60, this_._internal_nlmsg_seq(), target); + 17, this_._internal_nlmsg_seq(), target); } } - // uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + // uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_packet_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 70, this_._internal_packet_size(), target); + 18, this_._internal_packet_size(), target); } } - // uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + // uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_packet_size_mply() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 80, this_._internal_packet_size_mply(), target); + 19, this_._internal_packet_size_mply(), target); } } - // uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_write_files() != 0) { + // uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (this_._internal_modulus() != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 90, this_._internal_write_files(), target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 20, this_._internal_modulus(), target); } } - // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (!this_._internal_capture_path().empty()) { - const ::std::string& _s = this_._internal_capture_path(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.capture_path"); - target = stream->WriteStringMaybeAliased(100, _s, target); - } - } - - cached_has_bits = this_._impl_._has_bits_[1]; - // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (this_._internal_modulus() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 110, this_._internal_modulus(), target); - } + // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 21, *this_._impl_.enabled_deserializers_, this_._impl_.enabled_deserializers_->GetCachedSize(), target, + stream); } - cached_has_bits = this_._impl_._has_bits_[0]; - // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { + // bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (!this_._internal_marshal_to().empty()) { - const ::std::string& _s = this_._internal_marshal_to(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.marshal_to"); - target = stream->WriteStringMaybeAliased(120, _s, target); + if (this_._internal_io_uring() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 22, this_._internal_io_uring(), target); } } - cached_has_bits = this_._impl_._has_bits_[1]; - // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_envelope_flush_threshold_bytes() != 0) { + // uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (this_._internal_io_uring_recv_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 122, this_._internal_envelope_flush_threshold_bytes(), target); + 23, this_._internal_io_uring_recv_batch_size(), target); } } - cached_has_bits = this_._impl_._has_bits_[0]; - // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (this_._internal_envelope_flush_threshold_rows() != 0) { + // uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (this_._internal_io_uring_cqe_batch_size() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 123, this_._internal_envelope_flush_threshold_rows(), target); + 24, this_._internal_io_uring_cqe_batch_size(), target); } } - // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { - if (!this_._internal_kafka_compression().empty()) { - const ::std::string& _s = this_._internal_kafka_compression(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.kafka_compression"); - target = stream->WriteStringMaybeAliased(124, _s, target); - } + cached_has_bits = this_._impl_._has_bits_[1]; + // .google.protobuf.Duration reconcile_frequency = 40 [json_name = "reconcileFrequency", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 40, *this_._impl_.reconcile_frequency_, this_._impl_.reconcile_frequency_->GetCachedSize(), target, + stream); } - // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_s3_endpoint().empty()) { - const ::std::string& _s = this_._internal_s3_endpoint(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_endpoint"); - target = stream->WriteStringMaybeAliased(125, _s, target); + cached_has_bits = this_._impl_._has_bits_[0]; + // bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (this_._internal_reconcile_before_poll() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 41, this_._internal_reconcile_before_poll(), target); } } - // string s3_bucket = 126 [json_name = "s3Bucket", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (!this_._internal_s3_bucket().empty()) { - const ::std::string& _s = this_._internal_s3_bucket(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_bucket"); - target = stream->WriteStringMaybeAliased(126, _s, target); + cached_has_bits = this_._impl_._has_bits_[1]; + // uint32 write_files = 50 [json_name = "writeFiles", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (this_._internal_write_files() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 50, this_._internal_write_files(), target); } } - // string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_s3_prefix().empty()) { - const ::std::string& _s = this_._internal_s3_prefix(); + cached_has_bits = this_._impl_._has_bits_[0]; + // string capture_path = 51 [json_name = "capturePath", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (!this_._internal_capture_path().empty()) { + const ::std::string& _s = this_._internal_capture_path(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_prefix"); - target = stream->WriteStringMaybeAliased(127, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.capture_path"); + target = stream->WriteStringMaybeAliased(51, _s, target); } } - // string s3_access_key = 128 [json_name = "s3AccessKey", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (!this_._internal_s3_access_key().empty()) { - const ::std::string& _s = this_._internal_s3_access_key(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_access_key"); - target = stream->WriteStringMaybeAliased(128, _s, target); + cached_has_bits = this_._impl_._has_bits_[1]; + // uint32 dest_write_files = 52 [json_name = "destWriteFiles", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (this_._internal_dest_write_files() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 52, this_._internal_dest_write_files(), target); } } - // string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (!this_._internal_s3_secret_key().empty()) { - const ::std::string& _s = this_._internal_s3_secret_key(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_secret_key"); - target = stream->WriteStringMaybeAliased(129, _s, target); + // uint32 debug_level = 53 [json_name = "debugLevel", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (this_._internal_debug_level() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 53, this_._internal_debug_level(), target); } } - // string dest = 130 [json_name = "dest", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + cached_has_bits = this_._impl_._has_bits_[0]; + // string dest = 60 [json_name = "dest", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (!this_._internal_dest().empty()) { const ::std::string& _s = this_._internal_dest(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.dest"); - target = stream->WriteStringMaybeAliased(130, _s, target); - } - } - - cached_has_bits = this_._impl_._has_bits_[1]; - // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 132, this_._internal_s3_parquet_flush_threshold_bytes(), target); + target = stream->WriteStringMaybeAliased(60, _s, target); } } - cached_has_bits = this_._impl_._has_bits_[0]; - // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (!this_._internal_s3_region().empty()) { - const ::std::string& _s = this_._internal_s3_region(); + // string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_marshal_to().empty()) { + const ::std::string& _s = this_._internal_marshal_to(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_region"); - target = stream->WriteStringMaybeAliased(133, _s, target); - } - } - - cached_has_bits = this_._impl_._has_bits_[1]; - // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (this_._internal_s3_skip_bucket_probe() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 134, this_._internal_s3_skip_bucket_probe(), target); - } - } - - cached_has_bits = this_._impl_._has_bits_[0]; - // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_dest_write_files() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 135, this_._internal_dest_write_files(), target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.marshal_to"); + target = stream->WriteStringMaybeAliased(61, _s, target); } } - // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (!this_._internal_pyroscope_url().empty()) { - const ::std::string& _s = this_._internal_pyroscope_url(); + // string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (!this_._internal_csv_columns().empty()) { + const ::std::string& _s = this_._internal_csv_columns(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.pyroscope_url"); - target = stream->WriteStringMaybeAliased(136, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.csv_columns"); + target = stream->WriteStringMaybeAliased(62, _s, target); } } - // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (!this_._internal_pyroscope_app_name().empty()) { - const ::std::string& _s = this_._internal_pyroscope_app_name(); + // string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (!this_._internal_xtcp_proto_file().empty()) { + const ::std::string& _s = this_._internal_xtcp_proto_file(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.pyroscope_app_name"); - target = stream->WriteStringMaybeAliased(137, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.xtcp_proto_file"); + target = stream->WriteStringMaybeAliased(63, _s, target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_pyroscope_sample_hz() != 0) { + // uint32 envelope_flush_threshold_bytes = 64 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (this_._internal_envelope_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 138, this_._internal_pyroscope_sample_hz(), target); + 64, this_._internal_envelope_flush_threshold_bytes(), target); } } - // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (this_._internal_pyroscope_upload_interval_sec() != 0) { + // uint32 envelope_flush_threshold_rows = 65 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (this_._internal_envelope_flush_threshold_rows() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 139, this_._internal_pyroscope_upload_interval_sec(), target); + 65, this_._internal_envelope_flush_threshold_rows(), target); } } cached_has_bits = this_._impl_._has_bits_[0]; - // string topic = 140 [json_name = "topic", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + // string topic = 80 [json_name = "topic", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (!this_._internal_topic().empty()) { const ::std::string& _s = this_._internal_topic(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.topic"); - target = stream->WriteStringMaybeAliased(140, _s, target); + target = stream->WriteStringMaybeAliased(80, _s, target); } } - // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (!this_._internal_xtcp_proto_file().empty()) { - const ::std::string& _s = this_._internal_xtcp_proto_file(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.xtcp_proto_file"); - target = stream->WriteStringMaybeAliased(143, _s, target); - } - } - - // string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + // string kafka_schema_url = 81 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (!this_._internal_kafka_schema_url().empty()) { const ::std::string& _s = this_._internal_kafka_schema_url(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.kafka_schema_url"); - target = stream->WriteStringMaybeAliased(145, _s, target); + target = stream->WriteStringMaybeAliased(81, _s, target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + // .google.protobuf.Duration kafka_produce_timeout = 82 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 150, *this_._impl_.kafka_produce_timeout_, this_._impl_.kafka_produce_timeout_->GetCachedSize(), target, + 82, *this_._impl_.kafka_produce_timeout_, this_._impl_.kafka_produce_timeout_->GetCachedSize(), target, stream); } - // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (this_._internal_debug_level() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 160, this_._internal_debug_level(), target); + cached_has_bits = this_._impl_._has_bits_[0]; + // string kafka_compression = 83 [json_name = "kafkaCompression", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (!this_._internal_kafka_compression().empty()) { + const ::std::string& _s = this_._internal_kafka_compression(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.kafka_compression"); + target = stream->WriteStringMaybeAliased(83, _s, target); } } - cached_has_bits = this_._impl_._has_bits_[0]; - // string label = 170 [json_name = "label", (.buf.validate.field) = { + // string s3_endpoint = 100 [json_name = "s3Endpoint", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (!this_._internal_s3_endpoint().empty()) { + const ::std::string& _s = this_._internal_s3_endpoint(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_endpoint"); + target = stream->WriteStringMaybeAliased(100, _s, target); + } + } + + // string s3_region = 101 [json_name = "s3Region", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (!this_._internal_label().empty()) { - const ::std::string& _s = this_._internal_label(); + if (!this_._internal_s3_region().empty()) { + const ::std::string& _s = this_._internal_s3_region(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.label"); - target = stream->WriteStringMaybeAliased(170, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_region"); + target = stream->WriteStringMaybeAliased(101, _s, target); } } - // string tag = 180 [json_name = "tag", (.buf.validate.field) = { + // string s3_bucket = 102 [json_name = "s3Bucket", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (!this_._internal_tag().empty()) { - const ::std::string& _s = this_._internal_tag(); + if (!this_._internal_s3_bucket().empty()) { + const ::std::string& _s = this_._internal_s3_bucket(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.tag"); - target = stream->WriteStringMaybeAliased(180, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_bucket"); + target = stream->WriteStringMaybeAliased(102, _s, target); } } - // string location = 181 [json_name = "location", (.buf.validate.field) = { + // string s3_prefix = 103 [json_name = "s3Prefix", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (!this_._internal_location().empty()) { - const ::std::string& _s = this_._internal_location(); + if (!this_._internal_s3_prefix().empty()) { + const ::std::string& _s = this_._internal_s3_prefix(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.location"); - target = stream->WriteStringMaybeAliased(181, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_prefix"); + target = stream->WriteStringMaybeAliased(103, _s, target); } } - // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { + // string s3_access_key = 104 [json_name = "s3AccessKey", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (!this_._internal_hostname().empty()) { - const ::std::string& _s = this_._internal_hostname(); + if (!this_._internal_s3_access_key().empty()) { + const ::std::string& _s = this_._internal_s3_access_key(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.hostname"); - target = stream->WriteStringMaybeAliased(182, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_access_key"); + target = stream->WriteStringMaybeAliased(104, _s, target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (this_._internal_resolve_container_id() != 0) { + // string s3_secret_key = 105 [json_name = "s3SecretKey", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_s3_secret_key().empty()) { + const ::std::string& _s = this_._internal_s3_secret_key(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.s3_secret_key"); + target = stream->WriteStringMaybeAliased(105, _s, target); + } + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (this_._internal_s3_skip_bucket_probe() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 183, this_._internal_resolve_container_id(), target); + 106, this_._internal_s3_skip_bucket_probe(), target); } } - // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (this_._internal_ipv4_ttl() != 0) { + cached_has_bits = this_._impl_._has_bits_[1]; + // uint32 s3_parquet_flush_threshold_bytes = 110 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 184, this_._internal_ipv4_ttl(), target); + 110, this_._internal_s3_parquet_flush_threshold_bytes(), target); } } - // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00100000U)) { - if (this_._internal_ipv6_hop_limit() != 0) { + // .google.protobuf.Duration s3_flush_interval = 111 [json_name = "s3FlushInterval", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 111, *this_._impl_.s3_flush_interval_, this_._impl_.s3_flush_interval_->GetCachedSize(), target, + stream); + } + + // uint32 s3_flush_jitter_pct = 112 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (this_._internal_s3_flush_jitter_pct() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 185, this_._internal_ipv6_hop_limit(), target); + 112, this_._internal_s3_flush_jitter_pct(), target); } } - // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_daemon_version().empty()) { - const ::std::string& _s = this_._internal_daemon_version(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.daemon_version"); - target = stream->WriteStringMaybeAliased(186, _s, target); + // uint32 s3_flush_threshold_jitter_pct = 113 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 113, this_._internal_s3_flush_threshold_jitter_pct(), target); } } - // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { + // uint32 s3_upload_max_attempts = 114 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (this_._internal_grpc_port() != 0) { + if (this_._internal_s3_upload_max_attempts() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 190, this_._internal_grpc_port(), target); + 114, this_._internal_s3_upload_max_attempts(), target); } } - // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + // .google.protobuf.Duration s3_upload_backoff_cap = 115 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 200, *this_._impl_.enabled_deserializers_, this_._impl_.enabled_deserializers_->GetCachedSize(), target, + 115, *this_._impl_.s3_upload_backoff_cap_, this_._impl_.s3_upload_backoff_cap_->GetCachedSize(), target, stream); } - // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (this_._internal_io_uring() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 210, this_._internal_io_uring(), target); + // string hostname = 130 [json_name = "hostname", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_hostname().empty()) { + const ::std::string& _s = this_._internal_hostname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.hostname"); + target = stream->WriteStringMaybeAliased(130, _s, target); } } - // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { + // string location = 131 [json_name = "location", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (!this_._internal_location().empty()) { + const ::std::string& _s = this_._internal_location(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.location"); + target = stream->WriteStringMaybeAliased(131, _s, target); + } + } + + // string label = 132 [json_name = "label", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (!this_._internal_label().empty()) { + const ::std::string& _s = this_._internal_label(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.label"); + target = stream->WriteStringMaybeAliased(132, _s, target); + } + } + + // string tag = 133 [json_name = "tag", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (!this_._internal_tag().empty()) { + const ::std::string& _s = this_._internal_tag(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.tag"); + target = stream->WriteStringMaybeAliased(133, _s, target); + } + } + + // string daemon_version = 134 [json_name = "daemonVersion", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (!this_._internal_daemon_version().empty()) { + const ::std::string& _s = this_._internal_daemon_version(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.daemon_version"); + target = stream->WriteStringMaybeAliased(134, _s, target); + } + } + + // uint32 ipv4_ttl = 150 [json_name = "ipv4Ttl", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (this_._internal_io_uring_recv_batch_size() != 0) { + if (this_._internal_ipv4_ttl() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 211, this_._internal_io_uring_recv_batch_size(), target); + 150, this_._internal_ipv4_ttl(), target); } } - // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { + // uint32 ipv6_hop_limit = 151 [json_name = "ipv6HopLimit", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (this_._internal_io_uring_cqe_batch_size() != 0) { + if (this_._internal_ipv6_hop_limit() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 212, this_._internal_io_uring_cqe_batch_size(), target); + 151, this_._internal_ipv6_hop_limit(), target); } } - // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_csv_columns().empty()) { - const ::std::string& _s = this_._internal_csv_columns(); + // uint32 grpc_port = 160 [json_name = "grpcPort", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (this_._internal_grpc_port() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 160, this_._internal_grpc_port(), target); + } + } + + // string pyroscope_url = 170 [json_name = "pyroscopeUrl", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (!this_._internal_pyroscope_url().empty()) { + const ::std::string& _s = this_._internal_pyroscope_url(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.csv_columns"); - target = stream->WriteStringMaybeAliased(220, _s, target); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.pyroscope_url"); + target = stream->WriteStringMaybeAliased(170, _s, target); } } - // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (this_._internal_poll_jitter_pct() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 221, this_._internal_poll_jitter_pct(), target); + cached_has_bits = this_._impl_._has_bits_[0]; + // string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (!this_._internal_pyroscope_app_name().empty()) { + const ::std::string& _s = this_._internal_pyroscope_app_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.pyroscope_app_name"); + target = stream->WriteStringMaybeAliased(171, _s, target); } } - // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 222, *this_._impl_.s3_flush_interval_, this_._impl_.s3_flush_interval_->GetCachedSize(), target, - stream); - } - - // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { + cached_has_bits = this_._impl_._has_bits_[1]; + // uint32 pyroscope_sample_hz = 172 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_s3_flush_jitter_pct() != 0) { + if (this_._internal_pyroscope_sample_hz() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 223, this_._internal_s3_flush_jitter_pct(), target); + 172, this_._internal_pyroscope_sample_hz(), target); } } - // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { + // uint32 pyroscope_upload_interval_sec = 173 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { + if (this_._internal_pyroscope_upload_interval_sec() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 224, this_._internal_s3_flush_threshold_jitter_pct(), target); + 173, this_._internal_pyroscope_upload_interval_sec(), target); } } - // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { + // bool resolve_container_id = 200 [json_name = "resolveContainerId", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (this_._internal_s3_upload_max_attempts() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 225, this_._internal_s3_upload_max_attempts(), target); - } - } - - // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000200U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 226, *this_._impl_.s3_upload_backoff_cap_, this_._impl_.s3_upload_backoff_cap_->GetCachedSize(), target, - stream); - } - - // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000400U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 227, *this_._impl_.reconcile_frequency_, this_._impl_.reconcile_frequency_->GetCachedSize(), target, - stream); - } - - // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (this_._internal_reconcile_before_poll() != 0) { + if (this_._internal_resolve_container_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 228, this_._internal_reconcile_before_poll(), target); + 200, this_._internal_resolve_container_id(), target); } } cached_has_bits = this_._impl_._has_bits_[2]; - // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; + // bool enrich_container_enable = 201 [json_name = "enrichContainerEnable"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_container_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 230, this_._internal_enrich_container_enable(), target); + 201, this_._internal_enrich_container_enable(), target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + // string docker_socket_path = 202 [json_name = "dockerSocketPath", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (!this_._internal_docker_socket_path().empty()) { const ::std::string& _s = this_._internal_docker_socket_path(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.docker_socket_path"); - target = stream->WriteStringMaybeAliased(231, _s, target); + target = stream->WriteStringMaybeAliased(202, _s, target); } } cached_has_bits = this_._impl_._has_bits_[2]; - // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; + // bool enrich_lldp_enable = 210 [json_name = "enrichLldpEnable"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_lldp_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 232, this_._internal_enrich_lldp_enable(), target); + 210, this_._internal_enrich_lldp_enable(), target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + // string lldpd_socket_path = 211 [json_name = "lldpdSocketPath", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (!this_._internal_lldpd_socket_path().empty()) { const ::std::string& _s = this_._internal_lldpd_socket_path(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.lldpd_socket_path"); - target = stream->WriteStringMaybeAliased(233, _s, target); + target = stream->WriteStringMaybeAliased(211, _s, target); } } - // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + // string lldpd_version_hint = 212 [json_name = "lldpdVersionHint", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!this_._internal_lldpd_version_hint().empty()) { const ::std::string& _s = this_._internal_lldpd_version_hint(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.lldpd_version_hint"); - target = stream->WriteStringMaybeAliased(234, _s, target); + target = stream->WriteStringMaybeAliased(212, _s, target); } } cached_has_bits = this_._impl_._has_bits_[2]; - // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; + // bool enrich_nic_enable = 220 [json_name = "enrichNicEnable"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_enrich_nic_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 235, this_._internal_enrich_nic_enable(), target); + 220, this_._internal_enrich_nic_enable(), target); } } - // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + // uint32 uplink_count = 221 [json_name = "uplinkCount", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_uplink_count() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 236, this_._internal_uplink_count(), target); + 221, this_._internal_uplink_count(), target); } } cached_has_bits = this_._impl_._has_bits_[0]; - // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + // repeated string uplink_interfaces = 222 [json_name = "uplinkInterfaces", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { for (int i = 0, n = this_._internal_uplink_interfaces_size(); i < n; ++i) { const auto& s = this_._internal_uplink_interfaces().Get(i); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.uplink_interfaces"); - target = stream->WriteString(237, s, target); + target = stream->WriteString(222, s, target); } } cached_has_bits = this_._impl_._has_bits_[2]; - // bool populate_nsid = 238 [json_name = "populateNsid"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + // bool populate_nsid = 230 [json_name = "populateNsid"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_populate_nsid() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 238, this_._internal_populate_nsid(), target); + 230, this_._internal_populate_nsid(), target); } } - // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + // bool enrich_asn_enable = 240 [json_name = "enrichAsnEnable"]; if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_enrich_asn_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 239, this_._internal_enrich_asn_enable(), target); + 240, this_._internal_enrich_asn_enable(), target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + // string asn_db_path = 241 [json_name = "asnDbPath", (.buf.validate.field) = { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (!this_._internal_asn_db_path().empty()) { const ::std::string& _s = this_._internal_asn_db_path(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_config.v1.XtcpConfig.asn_db_path"); - target = stream->WriteStringMaybeAliased(240, _s, target); + target = stream->WriteStringMaybeAliased(241, _s, target); } } - // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + // .google.protobuf.Duration asn_refresh_interval = 242 [json_name = "asnRefreshInterval"]; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 241, *this_._impl_.asn_refresh_interval_, this_._impl_.asn_refresh_interval_->GetCachedSize(), target, + 242, *this_._impl_.asn_refresh_interval_, this_._impl_.asn_refresh_interval_->GetCachedSize(), target, stream); } cached_has_bits = this_._impl_._has_bits_[2]; - // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + // bool enrich_locality_enable = 245 [json_name = "enrichLocalityEnable"]; if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_enrich_locality_enable() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteBoolToArray( - 242, this_._internal_enrich_locality_enable(), target); + 245, this_._internal_enrich_locality_enable(), target); } } cached_has_bits = this_._impl_._has_bits_[1]; - // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + // .google.protobuf.Duration locality_refresh_interval = 246 [json_name = "localityRefreshInterval"]; + if (CheckHasBit(cached_has_bits, 0x00010000U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 243, *this_._impl_.locality_refresh_interval_, this_._impl_.locality_refresh_interval_->GetCachedSize(), target, + 246, *this_._impl_.locality_refresh_interval_, this_._impl_.locality_refresh_interval_->GetCachedSize(), target, stream); } @@ -7301,490 +7313,490 @@ ::size_t XtcpConfig::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { + // string dest = 60 [json_name = "dest", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_s3_endpoint().empty()) { + if (!this_._internal_dest().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_endpoint()); + this_._internal_dest()); } } - // string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { + // string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_s3_prefix().empty()) { + if (!this_._internal_marshal_to().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_prefix()); + this_._internal_marshal_to()); } } - // string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { + // string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (!this_._internal_s3_secret_key().empty()) { + if (!this_._internal_csv_columns().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_secret_key()); + this_._internal_csv_columns()); } } - // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { + // string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (!this_._internal_s3_region().empty()) { + if (!this_._internal_xtcp_proto_file().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_region()); + this_._internal_xtcp_proto_file()); } } - // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { + // string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (!this_._internal_pyroscope_app_name().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( this_._internal_pyroscope_app_name()); } } - // .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { + // .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000020U)) { - total_size += 2 + + total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.poll_frequency_); } - // .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { + // .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000040U)) { - total_size += 2 + + total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.poll_timeout_); } - // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { + // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000080U)) { - if (this_._internal_nl_timeout_milliseconds() != 0) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( - this_._internal_nl_timeout_milliseconds()); - } + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.enabled_deserializers_); } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - // uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { + // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (this_._internal_max_loops() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_max_loops()); + if (this_._internal_nl_timeout_milliseconds() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_nl_timeout_milliseconds()); } } - // uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { + // uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (this_._internal_netlinkers() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_netlinkers()); + if (this_._internal_max_loops() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal_max_loops()); } } - // uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { + // uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (this_._internal_netlinkers_done_chan_size() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_netlinkers_done_chan_size()); + if (this_._internal_poll_jitter_pct() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_poll_jitter_pct()); } } - // uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { + // uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (this_._internal_packet_size() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_packet_size()); + if (this_._internal_netlinkers() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_netlinkers()); } } - // uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { + // uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (this_._internal_nlmsg_seq() != 0) { + if (this_._internal_netlinkers_done_chan_size() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_nlmsg_seq()); + this_._internal_netlinkers_done_chan_size()); } } - // uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { + // uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (this_._internal_packet_size_mply() != 0) { + if (this_._internal_nlmsg_seq() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_packet_size_mply()); + this_._internal_nlmsg_seq()); } } - // uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { + // uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_write_files() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_write_files()); + if (this_._internal_packet_size() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_packet_size()); } } - // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { + // uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (this_._internal_envelope_flush_threshold_rows() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_envelope_flush_threshold_rows()); + if (this_._internal_modulus() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_modulus()); } } } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { + // uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_dest_write_files() != 0) { + if (this_._internal_packet_size_mply() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_dest_write_files()); + this_._internal_packet_size_mply()); } } - // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { + // uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00020000U)) { - total_size += - 2 * ::google::protobuf::internal::FromIntSize(this_._internal_uplink_interfaces().size()); - for (int i = 0, n = this_._internal_uplink_interfaces().size(); i < n; ++i) { - total_size += ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_uplink_interfaces().Get(i)); + if (this_._internal_io_uring_recv_batch_size() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_io_uring_recv_batch_size()); } } - // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { + // uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (!this_._internal_capture_path().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_capture_path()); + if (this_._internal_io_uring_cqe_batch_size() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_io_uring_cqe_batch_size()); } } - // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { + // bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (!this_._internal_marshal_to().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_marshal_to()); + if (this_._internal_io_uring() != 0) { + total_size += 3; } } - // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { + // bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; if (CheckHasBit(cached_has_bits, 0x00100000U)) { - if (!this_._internal_kafka_compression().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_kafka_compression()); + if (this_._internal_reconcile_before_poll() != 0) { + total_size += 3; } } - // string s3_bucket = 126 [json_name = "s3Bucket", (.buf.validate.field) = { + // bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (!this_._internal_s3_bucket().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_bucket()); + if (this_._internal_s3_skip_bucket_probe() != 0) { + total_size += 3; } } - // string s3_access_key = 128 [json_name = "s3AccessKey", (.buf.validate.field) = { + // repeated string uplink_interfaces = 222 [json_name = "uplinkInterfaces", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (!this_._internal_s3_access_key().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_s3_access_key()); + total_size += + 2 * ::google::protobuf::internal::FromIntSize(this_._internal_uplink_interfaces().size()); + for (int i = 0, n = this_._internal_uplink_interfaces().size(); i < n; ++i) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_uplink_interfaces().Get(i)); } } - // string dest = 130 [json_name = "dest", (.buf.validate.field) = { + // string capture_path = 51 [json_name = "capturePath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (!this_._internal_dest().empty()) { + if (!this_._internal_capture_path().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_dest()); + this_._internal_capture_path()); } } } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { + // string topic = 80 [json_name = "topic", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (!this_._internal_pyroscope_url().empty()) { + if (!this_._internal_topic().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_pyroscope_url()); + this_._internal_topic()); } } - // string topic = 140 [json_name = "topic", (.buf.validate.field) = { + // string kafka_schema_url = 81 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (!this_._internal_topic().empty()) { + if (!this_._internal_kafka_schema_url().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_topic()); + this_._internal_kafka_schema_url()); } } - // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { + // string kafka_compression = 83 [json_name = "kafkaCompression", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (!this_._internal_xtcp_proto_file().empty()) { + if (!this_._internal_kafka_compression().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_xtcp_proto_file()); + this_._internal_kafka_compression()); } } - // string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { + // string s3_endpoint = 100 [json_name = "s3Endpoint", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (!this_._internal_kafka_schema_url().empty()) { + if (!this_._internal_s3_endpoint().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_kafka_schema_url()); + this_._internal_s3_endpoint()); } } - // string label = 170 [json_name = "label", (.buf.validate.field) = { + // string s3_region = 101 [json_name = "s3Region", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (!this_._internal_label().empty()) { + if (!this_._internal_s3_region().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_label()); + this_._internal_s3_region()); } } - // string tag = 180 [json_name = "tag", (.buf.validate.field) = { + // string s3_bucket = 102 [json_name = "s3Bucket", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (!this_._internal_tag().empty()) { + if (!this_._internal_s3_bucket().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_tag()); + this_._internal_s3_bucket()); } } - // string location = 181 [json_name = "location", (.buf.validate.field) = { + // string s3_prefix = 103 [json_name = "s3Prefix", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (!this_._internal_location().empty()) { + if (!this_._internal_s3_prefix().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_location()); + this_._internal_s3_prefix()); } } - // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { + // string s3_access_key = 104 [json_name = "s3AccessKey", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (!this_._internal_hostname().empty()) { + if (!this_._internal_s3_access_key().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_hostname()); + this_._internal_s3_access_key()); } } } cached_has_bits = this_._impl_._has_bits_[1]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { + // string s3_secret_key = 105 [json_name = "s3SecretKey", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_daemon_version().empty()) { + if (!this_._internal_s3_secret_key().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_daemon_version()); + this_._internal_s3_secret_key()); } } - // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { + // string hostname = 130 [json_name = "hostname", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_csv_columns().empty()) { + if (!this_._internal_hostname().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_csv_columns()); + this_._internal_hostname()); } } - // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { + // string location = 131 [json_name = "location", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (!this_._internal_docker_socket_path().empty()) { + if (!this_._internal_location().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_docker_socket_path()); + this_._internal_location()); } } - // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { + // string label = 132 [json_name = "label", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (!this_._internal_lldpd_socket_path().empty()) { + if (!this_._internal_label().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_lldpd_socket_path()); + this_._internal_label()); } } - // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { + // string tag = 133 [json_name = "tag", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (!this_._internal_lldpd_version_hint().empty()) { + if (!this_._internal_tag().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_lldpd_version_hint()); + this_._internal_tag()); } } - // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { + // string daemon_version = 134 [json_name = "daemonVersion", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000020U)) { - if (!this_._internal_asn_db_path().empty()) { + if (!this_._internal_daemon_version().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_asn_db_path()); + this_._internal_daemon_version()); } } - // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + // string pyroscope_url = 170 [json_name = "pyroscopeUrl", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000040U)) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kafka_produce_timeout_); + if (!this_._internal_pyroscope_url().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_pyroscope_url()); + } } - // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { + // string docker_socket_path = 202 [json_name = "dockerSocketPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000080U)) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.enabled_deserializers_); + if (!this_._internal_docker_socket_path().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_docker_socket_path()); + } } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { + // string lldpd_socket_path = 211 [json_name = "lldpdSocketPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_flush_interval_); + if (!this_._internal_lldpd_socket_path().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_lldpd_socket_path()); + } } - // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { + // string lldpd_version_hint = 212 [json_name = "lldpdVersionHint", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000200U)) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_upload_backoff_cap_); + if (!this_._internal_lldpd_version_hint().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_lldpd_version_hint()); + } } - // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { + // string asn_db_path = 241 [json_name = "asnDbPath", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000400U)) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.reconcile_frequency_); + if (!this_._internal_asn_db_path().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_asn_db_path()); + } } - // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + // .google.protobuf.Duration reconcile_frequency = 40 [json_name = "reconcileFrequency", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000800U)) { total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.asn_refresh_interval_); + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.reconcile_frequency_); } - // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; + // .google.protobuf.Duration kafka_produce_timeout = 82 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00001000U)) { total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.locality_refresh_interval_); + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kafka_produce_timeout_); } - // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { + // .google.protobuf.Duration s3_flush_interval = 111 [json_name = "s3FlushInterval", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (this_._internal_modulus() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_modulus()); - } + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_flush_interval_); } - // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { + // .google.protobuf.Duration s3_upload_backoff_cap = 115 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_envelope_flush_threshold_bytes() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_envelope_flush_threshold_bytes()); - } + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.s3_upload_backoff_cap_); } - // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { + // .google.protobuf.Duration asn_refresh_interval = 242 [json_name = "asnRefreshInterval"]; if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_s3_parquet_flush_threshold_bytes()); - } + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.asn_refresh_interval_); } } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { + // .google.protobuf.Duration locality_refresh_interval = 246 [json_name = "localityRefreshInterval"]; if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_pyroscope_sample_hz() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_pyroscope_sample_hz()); - } + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.locality_refresh_interval_); } - // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { + // uint32 write_files = 50 [json_name = "writeFiles", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (this_._internal_pyroscope_upload_interval_sec() != 0) { + if (this_._internal_write_files() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_pyroscope_upload_interval_sec()); + this_._internal_write_files()); } } - // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { + // uint32 dest_write_files = 52 [json_name = "destWriteFiles", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (this_._internal_debug_level() != 0) { + if (this_._internal_dest_write_files() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_debug_level()); + this_._internal_dest_write_files()); } } - // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { + // uint32 debug_level = 53 [json_name = "debugLevel", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (this_._internal_ipv4_ttl() != 0) { + if (this_._internal_debug_level() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_ipv4_ttl()); + this_._internal_debug_level()); } } - // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { + // uint32 envelope_flush_threshold_bytes = 64 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00100000U)) { - if (this_._internal_ipv6_hop_limit() != 0) { + if (this_._internal_envelope_flush_threshold_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_ipv6_hop_limit()); + this_._internal_envelope_flush_threshold_bytes()); } } - // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { + // uint32 envelope_flush_threshold_rows = 65 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (this_._internal_s3_skip_bucket_probe() != 0) { - total_size += 3; + if (this_._internal_envelope_flush_threshold_rows() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_envelope_flush_threshold_rows()); } } - // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { + // uint32 s3_parquet_flush_threshold_bytes = 110 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (this_._internal_resolve_container_id() != 0) { - total_size += 3; + if (this_._internal_s3_parquet_flush_threshold_bytes() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_s3_parquet_flush_threshold_bytes()); } } - // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { + // uint32 s3_flush_jitter_pct = 112 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (this_._internal_io_uring() != 0) { - total_size += 3; + if (this_._internal_s3_flush_jitter_pct() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_s3_flush_jitter_pct()); } } } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; + // uint32 s3_flush_threshold_jitter_pct = 113 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (this_._internal_reconcile_before_poll() != 0) { - total_size += 3; + if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_s3_flush_threshold_jitter_pct()); } } - // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { + // uint32 s3_upload_max_attempts = 114 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (this_._internal_grpc_port() != 0) { + if (this_._internal_s3_upload_max_attempts() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_grpc_port()); + this_._internal_s3_upload_max_attempts()); } } - // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { + // uint32 ipv4_ttl = 150 [json_name = "ipv4Ttl", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (this_._internal_io_uring_recv_batch_size() != 0) { + if (this_._internal_ipv4_ttl() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_io_uring_recv_batch_size()); + this_._internal_ipv4_ttl()); } } - // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { + // uint32 ipv6_hop_limit = 151 [json_name = "ipv6HopLimit", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (this_._internal_io_uring_cqe_batch_size() != 0) { + if (this_._internal_ipv6_hop_limit() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_io_uring_cqe_batch_size()); + this_._internal_ipv6_hop_limit()); } } - // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { + // uint32 grpc_port = 160 [json_name = "grpcPort", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (this_._internal_poll_jitter_pct() != 0) { + if (this_._internal_grpc_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_poll_jitter_pct()); + this_._internal_grpc_port()); } } - // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { + // uint32 pyroscope_sample_hz = 172 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_s3_flush_jitter_pct() != 0) { + if (this_._internal_pyroscope_sample_hz() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_s3_flush_jitter_pct()); + this_._internal_pyroscope_sample_hz()); } } - // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { + // uint32 pyroscope_upload_interval_sec = 173 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (this_._internal_s3_flush_threshold_jitter_pct() != 0) { + if (this_._internal_pyroscope_upload_interval_sec() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_s3_flush_threshold_jitter_pct()); + this_._internal_pyroscope_upload_interval_sec()); } } - // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { + // bool resolve_container_id = 200 [json_name = "resolveContainerId", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (this_._internal_s3_upload_max_attempts() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_s3_upload_max_attempts()); + if (this_._internal_resolve_container_id() != 0) { + total_size += 3; } } } cached_has_bits = this_._impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) { - // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; + // bool enrich_container_enable = 201 [json_name = "enrichContainerEnable"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_enrich_container_enable() != 0) { total_size += 3; } } - // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; + // bool enrich_lldp_enable = 210 [json_name = "enrichLldpEnable"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_enrich_lldp_enable() != 0) { total_size += 3; } } - // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; + // bool enrich_nic_enable = 220 [json_name = "enrichNicEnable"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_enrich_nic_enable() != 0) { total_size += 3; } } - // bool populate_nsid = 238 [json_name = "populateNsid"]; + // uint32 uplink_count = 221 [json_name = "uplinkCount", (.buf.validate.field) = { if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (this_._internal_populate_nsid() != 0) { - total_size += 3; - } - } - // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { - if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_uplink_count() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink_count()); } } - // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + // bool populate_nsid = 230 [json_name = "populateNsid"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_populate_nsid() != 0) { + total_size += 3; + } + } + // bool enrich_asn_enable = 240 [json_name = "enrichAsnEnable"]; if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_enrich_asn_enable() != 0) { total_size += 3; } } - // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + // bool enrich_locality_enable = 245 [json_name = "enrichLocalityEnable"]; if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_enrich_locality_enable() != 0) { total_size += 3; @@ -7811,38 +7823,38 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_s3_endpoint().empty()) { - _this->_internal_set_s3_endpoint(from._internal_s3_endpoint()); + if (!from._internal_dest().empty()) { + _this->_internal_set_dest(from._internal_dest()); } else { - if (_this->_impl_.s3_endpoint_.IsDefault()) { - _this->_internal_set_s3_endpoint(""); + if (_this->_impl_.dest_.IsDefault()) { + _this->_internal_set_dest(""); } } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_s3_prefix().empty()) { - _this->_internal_set_s3_prefix(from._internal_s3_prefix()); + if (!from._internal_marshal_to().empty()) { + _this->_internal_set_marshal_to(from._internal_marshal_to()); } else { - if (_this->_impl_.s3_prefix_.IsDefault()) { - _this->_internal_set_s3_prefix(""); + if (_this->_impl_.marshal_to_.IsDefault()) { + _this->_internal_set_marshal_to(""); } } } if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (!from._internal_s3_secret_key().empty()) { - _this->_internal_set_s3_secret_key(from._internal_s3_secret_key()); + if (!from._internal_csv_columns().empty()) { + _this->_internal_set_csv_columns(from._internal_csv_columns()); } else { - if (_this->_impl_.s3_secret_key_.IsDefault()) { - _this->_internal_set_s3_secret_key(""); + if (_this->_impl_.csv_columns_.IsDefault()) { + _this->_internal_set_csv_columns(""); } } } if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (!from._internal_s3_region().empty()) { - _this->_internal_set_s3_region(from._internal_s3_region()); + if (!from._internal_xtcp_proto_file().empty()) { + _this->_internal_set_xtcp_proto_file(from._internal_xtcp_proto_file()); } else { - if (_this->_impl_.s3_region_.IsDefault()) { - _this->_internal_set_s3_region(""); + if (_this->_impl_.xtcp_proto_file_.IsDefault()) { + _this->_internal_set_xtcp_proto_file(""); } } } @@ -7872,65 +7884,93 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000080U)) { - if (from._internal_nl_timeout_milliseconds() != 0) { - _this->_impl_.nl_timeout_milliseconds_ = from._impl_.nl_timeout_milliseconds_; + ABSL_DCHECK(from._impl_.enabled_deserializers_ != nullptr); + if (_this->_impl_.enabled_deserializers_ == nullptr) { + _this->_impl_.enabled_deserializers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_); + } else { + _this->_impl_.enabled_deserializers_->MergeFrom(*from._impl_.enabled_deserializers_); } } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (from._internal_max_loops() != 0) { - _this->_impl_.max_loops_ = from._impl_.max_loops_; + if (from._internal_nl_timeout_milliseconds() != 0) { + _this->_impl_.nl_timeout_milliseconds_ = from._impl_.nl_timeout_milliseconds_; } } if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (from._internal_netlinkers() != 0) { - _this->_impl_.netlinkers_ = from._impl_.netlinkers_; + if (from._internal_max_loops() != 0) { + _this->_impl_.max_loops_ = from._impl_.max_loops_; } } if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (from._internal_netlinkers_done_chan_size() != 0) { - _this->_impl_.netlinkers_done_chan_size_ = from._impl_.netlinkers_done_chan_size_; + if (from._internal_poll_jitter_pct() != 0) { + _this->_impl_.poll_jitter_pct_ = from._impl_.poll_jitter_pct_; } } if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (from._internal_packet_size() != 0) { - _this->_impl_.packet_size_ = from._impl_.packet_size_; + if (from._internal_netlinkers() != 0) { + _this->_impl_.netlinkers_ = from._impl_.netlinkers_; } } if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (from._internal_nlmsg_seq() != 0) { - _this->_impl_.nlmsg_seq_ = from._impl_.nlmsg_seq_; + if (from._internal_netlinkers_done_chan_size() != 0) { + _this->_impl_.netlinkers_done_chan_size_ = from._impl_.netlinkers_done_chan_size_; } } if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (from._internal_packet_size_mply() != 0) { - _this->_impl_.packet_size_mply_ = from._impl_.packet_size_mply_; + if (from._internal_nlmsg_seq() != 0) { + _this->_impl_.nlmsg_seq_ = from._impl_.nlmsg_seq_; } } if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (from._internal_write_files() != 0) { - _this->_impl_.write_files_ = from._impl_.write_files_; + if (from._internal_packet_size() != 0) { + _this->_impl_.packet_size_ = from._impl_.packet_size_; } } if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (from._internal_envelope_flush_threshold_rows() != 0) { - _this->_impl_.envelope_flush_threshold_rows_ = from._impl_.envelope_flush_threshold_rows_; + if (from._internal_modulus() != 0) { + _this->_impl_.modulus_ = from._impl_.modulus_; } } } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (from._internal_dest_write_files() != 0) { - _this->_impl_.dest_write_files_ = from._impl_.dest_write_files_; + if (from._internal_packet_size_mply() != 0) { + _this->_impl_.packet_size_mply_ = from._impl_.packet_size_mply_; } } if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (from._internal_io_uring_recv_batch_size() != 0) { + _this->_impl_.io_uring_recv_batch_size_ = from._impl_.io_uring_recv_batch_size_; + } + } + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (from._internal_io_uring_cqe_batch_size() != 0) { + _this->_impl_.io_uring_cqe_batch_size_ = from._impl_.io_uring_cqe_batch_size_; + } + } + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (from._internal_io_uring() != 0) { + _this->_impl_.io_uring_ = from._impl_.io_uring_; + } + } + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (from._internal_reconcile_before_poll() != 0) { + _this->_impl_.reconcile_before_poll_ = from._impl_.reconcile_before_poll_; + } + } + if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (from._internal_s3_skip_bucket_probe() != 0) { + _this->_impl_.s3_skip_bucket_probe_ = from._impl_.s3_skip_bucket_probe_; + } + } + if (CheckHasBit(cached_has_bits, 0x00400000U)) { _this->_internal_mutable_uplink_interfaces()->InternalMergeFromWithArena( ::google::protobuf::MessageLite::internal_visibility(), arena, from._internal_uplink_interfaces()); } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (!from._internal_capture_path().empty()) { _this->_internal_set_capture_path(from._internal_capture_path()); } else { @@ -7939,16 +7979,27 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (!from._internal_marshal_to().empty()) { - _this->_internal_set_marshal_to(from._internal_marshal_to()); + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (!from._internal_topic().empty()) { + _this->_internal_set_topic(from._internal_topic()); } else { - if (_this->_impl_.marshal_to_.IsDefault()) { - _this->_internal_set_marshal_to(""); + if (_this->_impl_.topic_.IsDefault()) { + _this->_internal_set_topic(""); } } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (!from._internal_kafka_schema_url().empty()) { + _this->_internal_set_kafka_schema_url(from._internal_kafka_schema_url()); + } else { + if (_this->_impl_.kafka_schema_url_.IsDefault()) { + _this->_internal_set_kafka_schema_url(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (!from._internal_kafka_compression().empty()) { _this->_internal_set_kafka_compression(from._internal_kafka_compression()); } else { @@ -7957,7 +8008,25 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (!from._internal_s3_endpoint().empty()) { + _this->_internal_set_s3_endpoint(from._internal_s3_endpoint()); + } else { + if (_this->_impl_.s3_endpoint_.IsDefault()) { + _this->_internal_set_s3_endpoint(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (!from._internal_s3_region().empty()) { + _this->_internal_set_s3_region(from._internal_s3_region()); + } else { + if (_this->_impl_.s3_region_.IsDefault()) { + _this->_internal_set_s3_region(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (!from._internal_s3_bucket().empty()) { _this->_internal_set_s3_bucket(from._internal_s3_bucket()); } else { @@ -7966,7 +8035,16 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (!from._internal_s3_prefix().empty()) { + _this->_internal_set_s3_prefix(from._internal_s3_prefix()); + } else { + if (_this->_impl_.s3_prefix_.IsDefault()) { + _this->_internal_set_s3_prefix(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (!from._internal_s3_access_key().empty()) { _this->_internal_set_s3_access_key(from._internal_s3_access_key()); } else { @@ -7975,54 +8053,37 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (!from._internal_dest().empty()) { - _this->_internal_set_dest(from._internal_dest()); - } else { - if (_this->_impl_.dest_.IsDefault()) { - _this->_internal_set_dest(""); - } - } - } } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (!from._internal_pyroscope_url().empty()) { - _this->_internal_set_pyroscope_url(from._internal_pyroscope_url()); - } else { - if (_this->_impl_.pyroscope_url_.IsDefault()) { - _this->_internal_set_pyroscope_url(""); - } - } - } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (!from._internal_topic().empty()) { - _this->_internal_set_topic(from._internal_topic()); + cached_has_bits = from._impl_._has_bits_[1]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_s3_secret_key().empty()) { + _this->_internal_set_s3_secret_key(from._internal_s3_secret_key()); } else { - if (_this->_impl_.topic_.IsDefault()) { - _this->_internal_set_topic(""); + if (_this->_impl_.s3_secret_key_.IsDefault()) { + _this->_internal_set_s3_secret_key(""); } } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (!from._internal_xtcp_proto_file().empty()) { - _this->_internal_set_xtcp_proto_file(from._internal_xtcp_proto_file()); + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_hostname().empty()) { + _this->_internal_set_hostname(from._internal_hostname()); } else { - if (_this->_impl_.xtcp_proto_file_.IsDefault()) { - _this->_internal_set_xtcp_proto_file(""); + if (_this->_impl_.hostname_.IsDefault()) { + _this->_internal_set_hostname(""); } } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (!from._internal_kafka_schema_url().empty()) { - _this->_internal_set_kafka_schema_url(from._internal_kafka_schema_url()); + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (!from._internal_location().empty()) { + _this->_internal_set_location(from._internal_location()); } else { - if (_this->_impl_.kafka_schema_url_.IsDefault()) { - _this->_internal_set_kafka_schema_url(""); + if (_this->_impl_.location_.IsDefault()) { + _this->_internal_set_location(""); } } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (!from._internal_label().empty()) { _this->_internal_set_label(from._internal_label()); } else { @@ -8031,7 +8092,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (!from._internal_tag().empty()) { _this->_internal_set_tag(from._internal_tag()); } else { @@ -8040,28 +8101,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (!from._internal_location().empty()) { - _this->_internal_set_location(from._internal_location()); - } else { - if (_this->_impl_.location_.IsDefault()) { - _this->_internal_set_location(""); - } - } - } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (!from._internal_hostname().empty()) { - _this->_internal_set_hostname(from._internal_hostname()); - } else { - if (_this->_impl_.hostname_.IsDefault()) { - _this->_internal_set_hostname(""); - } - } - } - } - cached_has_bits = from._impl_._has_bits_[1]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (!from._internal_daemon_version().empty()) { _this->_internal_set_daemon_version(from._internal_daemon_version()); } else { @@ -8070,16 +8110,16 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_csv_columns().empty()) { - _this->_internal_set_csv_columns(from._internal_csv_columns()); + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (!from._internal_pyroscope_url().empty()) { + _this->_internal_set_pyroscope_url(from._internal_pyroscope_url()); } else { - if (_this->_impl_.csv_columns_.IsDefault()) { - _this->_internal_set_csv_columns(""); + if (_this->_impl_.pyroscope_url_.IsDefault()) { + _this->_internal_set_pyroscope_url(""); } } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (!from._internal_docker_socket_path().empty()) { _this->_internal_set_docker_socket_path(from._internal_docker_socket_path()); } else { @@ -8088,7 +8128,9 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (!from._internal_lldpd_socket_path().empty()) { _this->_internal_set_lldpd_socket_path(from._internal_lldpd_socket_path()); } else { @@ -8097,7 +8139,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!from._internal_lldpd_version_hint().empty()) { _this->_internal_set_lldpd_version_hint(from._internal_lldpd_version_hint()); } else { @@ -8106,7 +8148,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (!from._internal_asn_db_path().empty()) { _this->_internal_set_asn_db_path(from._internal_asn_db_path()); } else { @@ -8115,7 +8157,15 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + ABSL_DCHECK(from._impl_.reconcile_frequency_ != nullptr); + if (_this->_impl_.reconcile_frequency_ == nullptr) { + _this->_impl_.reconcile_frequency_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_); + } else { + _this->_impl_.reconcile_frequency_->MergeFrom(*from._impl_.reconcile_frequency_); + } + } + if (CheckHasBit(cached_has_bits, 0x00001000U)) { ABSL_DCHECK(from._impl_.kafka_produce_timeout_ != nullptr); if (_this->_impl_.kafka_produce_timeout_ == nullptr) { _this->_impl_.kafka_produce_timeout_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kafka_produce_timeout_); @@ -8123,17 +8173,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.kafka_produce_timeout_->MergeFrom(*from._impl_.kafka_produce_timeout_); } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { - ABSL_DCHECK(from._impl_.enabled_deserializers_ != nullptr); - if (_this->_impl_.enabled_deserializers_ == nullptr) { - _this->_impl_.enabled_deserializers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.enabled_deserializers_); - } else { - _this->_impl_.enabled_deserializers_->MergeFrom(*from._impl_.enabled_deserializers_); - } - } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { ABSL_DCHECK(from._impl_.s3_flush_interval_ != nullptr); if (_this->_impl_.s3_flush_interval_ == nullptr) { _this->_impl_.s3_flush_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_flush_interval_); @@ -8141,7 +8181,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.s3_flush_interval_->MergeFrom(*from._impl_.s3_flush_interval_); } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { ABSL_DCHECK(from._impl_.s3_upload_backoff_cap_ != nullptr); if (_this->_impl_.s3_upload_backoff_cap_ == nullptr) { _this->_impl_.s3_upload_backoff_cap_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.s3_upload_backoff_cap_); @@ -8149,15 +8189,7 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.s3_upload_backoff_cap_->MergeFrom(*from._impl_.s3_upload_backoff_cap_); } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { - ABSL_DCHECK(from._impl_.reconcile_frequency_ != nullptr); - if (_this->_impl_.reconcile_frequency_ == nullptr) { - _this->_impl_.reconcile_frequency_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.reconcile_frequency_); - } else { - _this->_impl_.reconcile_frequency_->MergeFrom(*from._impl_.reconcile_frequency_); - } - } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { ABSL_DCHECK(from._impl_.asn_refresh_interval_ != nullptr); if (_this->_impl_.asn_refresh_interval_ == nullptr) { _this->_impl_.asn_refresh_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.asn_refresh_interval_); @@ -8165,7 +8197,9 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.asn_refresh_interval_->MergeFrom(*from._impl_.asn_refresh_interval_); } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { ABSL_DCHECK(from._impl_.locality_refresh_interval_ != nullptr); if (_this->_impl_.locality_refresh_interval_ == nullptr) { _this->_impl_.locality_refresh_interval_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.locality_refresh_interval_); @@ -8173,103 +8207,81 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.locality_refresh_interval_->MergeFrom(*from._impl_.locality_refresh_interval_); } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { - if (from._internal_modulus() != 0) { - _this->_impl_.modulus_ = from._impl_.modulus_; - } - } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (from._internal_envelope_flush_threshold_bytes() != 0) { - _this->_impl_.envelope_flush_threshold_bytes_ = from._impl_.envelope_flush_threshold_bytes_; - } - } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { - if (from._internal_s3_parquet_flush_threshold_bytes() != 0) { - _this->_impl_.s3_parquet_flush_threshold_bytes_ = from._impl_.s3_parquet_flush_threshold_bytes_; - } - } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (from._internal_pyroscope_sample_hz() != 0) { - _this->_impl_.pyroscope_sample_hz_ = from._impl_.pyroscope_sample_hz_; - } - } if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (from._internal_pyroscope_upload_interval_sec() != 0) { - _this->_impl_.pyroscope_upload_interval_sec_ = from._impl_.pyroscope_upload_interval_sec_; + if (from._internal_write_files() != 0) { + _this->_impl_.write_files_ = from._impl_.write_files_; } } if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (from._internal_debug_level() != 0) { - _this->_impl_.debug_level_ = from._impl_.debug_level_; + if (from._internal_dest_write_files() != 0) { + _this->_impl_.dest_write_files_ = from._impl_.dest_write_files_; } } if (CheckHasBit(cached_has_bits, 0x00080000U)) { - if (from._internal_ipv4_ttl() != 0) { - _this->_impl_.ipv4_ttl_ = from._impl_.ipv4_ttl_; + if (from._internal_debug_level() != 0) { + _this->_impl_.debug_level_ = from._impl_.debug_level_; } } if (CheckHasBit(cached_has_bits, 0x00100000U)) { - if (from._internal_ipv6_hop_limit() != 0) { - _this->_impl_.ipv6_hop_limit_ = from._impl_.ipv6_hop_limit_; + if (from._internal_envelope_flush_threshold_bytes() != 0) { + _this->_impl_.envelope_flush_threshold_bytes_ = from._impl_.envelope_flush_threshold_bytes_; } } if (CheckHasBit(cached_has_bits, 0x00200000U)) { - if (from._internal_s3_skip_bucket_probe() != 0) { - _this->_impl_.s3_skip_bucket_probe_ = from._impl_.s3_skip_bucket_probe_; + if (from._internal_envelope_flush_threshold_rows() != 0) { + _this->_impl_.envelope_flush_threshold_rows_ = from._impl_.envelope_flush_threshold_rows_; } } if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (from._internal_resolve_container_id() != 0) { - _this->_impl_.resolve_container_id_ = from._impl_.resolve_container_id_; + if (from._internal_s3_parquet_flush_threshold_bytes() != 0) { + _this->_impl_.s3_parquet_flush_threshold_bytes_ = from._impl_.s3_parquet_flush_threshold_bytes_; } } if (CheckHasBit(cached_has_bits, 0x00800000U)) { - if (from._internal_io_uring() != 0) { - _this->_impl_.io_uring_ = from._impl_.io_uring_; + if (from._internal_s3_flush_jitter_pct() != 0) { + _this->_impl_.s3_flush_jitter_pct_ = from._impl_.s3_flush_jitter_pct_; } } } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (from._internal_reconcile_before_poll() != 0) { - _this->_impl_.reconcile_before_poll_ = from._impl_.reconcile_before_poll_; + if (from._internal_s3_flush_threshold_jitter_pct() != 0) { + _this->_impl_.s3_flush_threshold_jitter_pct_ = from._impl_.s3_flush_threshold_jitter_pct_; } } if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (from._internal_grpc_port() != 0) { - _this->_impl_.grpc_port_ = from._impl_.grpc_port_; + if (from._internal_s3_upload_max_attempts() != 0) { + _this->_impl_.s3_upload_max_attempts_ = from._impl_.s3_upload_max_attempts_; } } if (CheckHasBit(cached_has_bits, 0x04000000U)) { - if (from._internal_io_uring_recv_batch_size() != 0) { - _this->_impl_.io_uring_recv_batch_size_ = from._impl_.io_uring_recv_batch_size_; + if (from._internal_ipv4_ttl() != 0) { + _this->_impl_.ipv4_ttl_ = from._impl_.ipv4_ttl_; } } if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (from._internal_io_uring_cqe_batch_size() != 0) { - _this->_impl_.io_uring_cqe_batch_size_ = from._impl_.io_uring_cqe_batch_size_; + if (from._internal_ipv6_hop_limit() != 0) { + _this->_impl_.ipv6_hop_limit_ = from._impl_.ipv6_hop_limit_; } } if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (from._internal_poll_jitter_pct() != 0) { - _this->_impl_.poll_jitter_pct_ = from._impl_.poll_jitter_pct_; + if (from._internal_grpc_port() != 0) { + _this->_impl_.grpc_port_ = from._impl_.grpc_port_; } } if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (from._internal_s3_flush_jitter_pct() != 0) { - _this->_impl_.s3_flush_jitter_pct_ = from._impl_.s3_flush_jitter_pct_; + if (from._internal_pyroscope_sample_hz() != 0) { + _this->_impl_.pyroscope_sample_hz_ = from._impl_.pyroscope_sample_hz_; } } if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (from._internal_s3_flush_threshold_jitter_pct() != 0) { - _this->_impl_.s3_flush_threshold_jitter_pct_ = from._impl_.s3_flush_threshold_jitter_pct_; + if (from._internal_pyroscope_upload_interval_sec() != 0) { + _this->_impl_.pyroscope_upload_interval_sec_ = from._impl_.pyroscope_upload_interval_sec_; } } if (CheckHasBit(cached_has_bits, 0x80000000U)) { - if (from._internal_s3_upload_max_attempts() != 0) { - _this->_impl_.s3_upload_max_attempts_ = from._impl_.s3_upload_max_attempts_; + if (from._internal_resolve_container_id() != 0) { + _this->_impl_.resolve_container_id_ = from._impl_.resolve_container_id_; } } } @@ -8291,13 +8303,13 @@ void XtcpConfig::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (from._internal_populate_nsid() != 0) { - _this->_impl_.populate_nsid_ = from._impl_.populate_nsid_; + if (from._internal_uplink_count() != 0) { + _this->_impl_.uplink_count_ = from._impl_.uplink_count_; } } if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (from._internal_uplink_count() != 0) { - _this->_impl_.uplink_count_ = from._impl_.uplink_count_; + if (from._internal_populate_nsid() != 0) { + _this->_impl_.populate_nsid_ = from._impl_.populate_nsid_; } } if (CheckHasBit(cached_has_bits, 0x00000020U)) { @@ -8332,34 +8344,34 @@ void XtcpConfig::InternalSwap(XtcpConfig* PROTOBUF_RESTRICT PROTOBUF_NONNULL oth swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); swap(_impl_._has_bits_[2], other->_impl_._has_bits_[2]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_endpoint_, &other->_impl_.s3_endpoint_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_prefix_, &other->_impl_.s3_prefix_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_secret_key_, &other->_impl_.s3_secret_key_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_region_, &other->_impl_.s3_region_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.dest_, &other->_impl_.dest_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.marshal_to_, &other->_impl_.marshal_to_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.csv_columns_, &other->_impl_.csv_columns_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.xtcp_proto_file_, &other->_impl_.xtcp_proto_file_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.pyroscope_app_name_, &other->_impl_.pyroscope_app_name_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.dest_write_files_) - + sizeof(XtcpConfig::_impl_.dest_write_files_) + PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.s3_skip_bucket_probe_) + + sizeof(XtcpConfig::_impl_.s3_skip_bucket_probe_) - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.poll_frequency_)>( reinterpret_cast(&_impl_.poll_frequency_), reinterpret_cast(&other->_impl_.poll_frequency_)); _impl_.uplink_interfaces_.InternalSwap(&other->_impl_.uplink_interfaces_); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.capture_path_, &other->_impl_.capture_path_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.marshal_to_, &other->_impl_.marshal_to_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.topic_, &other->_impl_.topic_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.kafka_schema_url_, &other->_impl_.kafka_schema_url_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.kafka_compression_, &other->_impl_.kafka_compression_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_endpoint_, &other->_impl_.s3_endpoint_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_region_, &other->_impl_.s3_region_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_bucket_, &other->_impl_.s3_bucket_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_prefix_, &other->_impl_.s3_prefix_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_access_key_, &other->_impl_.s3_access_key_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.dest_, &other->_impl_.dest_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.pyroscope_url_, &other->_impl_.pyroscope_url_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.topic_, &other->_impl_.topic_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.xtcp_proto_file_, &other->_impl_.xtcp_proto_file_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.kafka_schema_url_, &other->_impl_.kafka_schema_url_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.s3_secret_key_, &other->_impl_.s3_secret_key_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.hostname_, &other->_impl_.hostname_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.location_, &other->_impl_.location_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.label_, &other->_impl_.label_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.tag_, &other->_impl_.tag_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.location_, &other->_impl_.location_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.hostname_, &other->_impl_.hostname_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.daemon_version_, &other->_impl_.daemon_version_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.csv_columns_, &other->_impl_.csv_columns_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.pyroscope_url_, &other->_impl_.pyroscope_url_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.docker_socket_path_, &other->_impl_.docker_socket_path_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.lldpd_socket_path_, &other->_impl_.lldpd_socket_path_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.lldpd_version_hint_, &other->_impl_.lldpd_version_hint_, arena); @@ -8367,9 +8379,9 @@ void XtcpConfig::InternalSwap(XtcpConfig* PROTOBUF_RESTRICT PROTOBUF_NONNULL oth ::google::protobuf::internal::memswap< PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.enrich_locality_enable_) + sizeof(XtcpConfig::_impl_.enrich_locality_enable_) - - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.kafka_produce_timeout_)>( - reinterpret_cast(&_impl_.kafka_produce_timeout_), - reinterpret_cast(&other->_impl_.kafka_produce_timeout_)); + - PROTOBUF_FIELD_OFFSET(XtcpConfig, _impl_.reconcile_frequency_)>( + reinterpret_cast(&_impl_.reconcile_frequency_), + reinterpret_cast(&other->_impl_.reconcile_frequency_)); } ::google::protobuf::Metadata XtcpConfig::GetMetadata() const { diff --git a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h index 43f4e56..e91f77e 100644 --- a/gen/cpp/xtcp_config/v1/xtcp_config.pb.h +++ b/gen/cpp/xtcp_config/v1/xtcp_config.pb.h @@ -2127,139 +2127,139 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: // accessors ------------------------------------------------------- enum : int { - kS3EndpointFieldNumber = 125, - kS3PrefixFieldNumber = 127, - kS3SecretKeyFieldNumber = 129, - kS3RegionFieldNumber = 133, - kPyroscopeAppNameFieldNumber = 137, - kPollFrequencyFieldNumber = 20, - kPollTimeoutFieldNumber = 30, + kDestFieldNumber = 60, + kMarshalToFieldNumber = 61, + kCsvColumnsFieldNumber = 62, + kXtcpProtoFileFieldNumber = 63, + kPyroscopeAppNameFieldNumber = 171, + kPollFrequencyFieldNumber = 11, + kPollTimeoutFieldNumber = 12, + kEnabledDeserializersFieldNumber = 21, kNlTimeoutMillisecondsFieldNumber = 10, - kMaxLoopsFieldNumber = 40, - kNetlinkersFieldNumber = 50, - kNetlinkersDoneChanSizeFieldNumber = 51, - kPacketSizeFieldNumber = 70, - kNlmsgSeqFieldNumber = 60, - kPacketSizeMplyFieldNumber = 80, - kWriteFilesFieldNumber = 90, - kEnvelopeFlushThresholdRowsFieldNumber = 123, - kDestWriteFilesFieldNumber = 135, - kUplinkInterfacesFieldNumber = 237, - kCapturePathFieldNumber = 100, - kMarshalToFieldNumber = 120, - kKafkaCompressionFieldNumber = 124, - kS3BucketFieldNumber = 126, - kS3AccessKeyFieldNumber = 128, - kDestFieldNumber = 130, - kPyroscopeUrlFieldNumber = 136, - kTopicFieldNumber = 140, - kXtcpProtoFileFieldNumber = 143, - kKafkaSchemaUrlFieldNumber = 145, - kLabelFieldNumber = 170, - kTagFieldNumber = 180, - kLocationFieldNumber = 181, - kHostnameFieldNumber = 182, - kDaemonVersionFieldNumber = 186, - kCsvColumnsFieldNumber = 220, - kDockerSocketPathFieldNumber = 231, - kLldpdSocketPathFieldNumber = 233, - kLldpdVersionHintFieldNumber = 234, - kAsnDbPathFieldNumber = 240, - kKafkaProduceTimeoutFieldNumber = 150, - kEnabledDeserializersFieldNumber = 200, - kS3FlushIntervalFieldNumber = 222, - kS3UploadBackoffCapFieldNumber = 226, - kReconcileFrequencyFieldNumber = 227, - kAsnRefreshIntervalFieldNumber = 241, - kLocalityRefreshIntervalFieldNumber = 243, - kModulusFieldNumber = 110, - kEnvelopeFlushThresholdBytesFieldNumber = 122, - kS3ParquetFlushThresholdBytesFieldNumber = 132, - kPyroscopeSampleHzFieldNumber = 138, - kPyroscopeUploadIntervalSecFieldNumber = 139, - kDebugLevelFieldNumber = 160, - kIpv4TtlFieldNumber = 184, - kIpv6HopLimitFieldNumber = 185, - kS3SkipBucketProbeFieldNumber = 134, - kResolveContainerIdFieldNumber = 183, - kIoUringFieldNumber = 210, - kReconcileBeforePollFieldNumber = 228, - kGrpcPortFieldNumber = 190, - kIoUringRecvBatchSizeFieldNumber = 211, - kIoUringCqeBatchSizeFieldNumber = 212, - kPollJitterPctFieldNumber = 221, - kS3FlushJitterPctFieldNumber = 223, - kS3FlushThresholdJitterPctFieldNumber = 224, - kS3UploadMaxAttemptsFieldNumber = 225, - kEnrichContainerEnableFieldNumber = 230, - kEnrichLldpEnableFieldNumber = 232, - kEnrichNicEnableFieldNumber = 235, - kPopulateNsidFieldNumber = 238, - kUplinkCountFieldNumber = 236, - kEnrichAsnEnableFieldNumber = 239, - kEnrichLocalityEnableFieldNumber = 242, + kMaxLoopsFieldNumber = 14, + kPollJitterPctFieldNumber = 13, + kNetlinkersFieldNumber = 15, + kNetlinkersDoneChanSizeFieldNumber = 16, + kNlmsgSeqFieldNumber = 17, + kPacketSizeFieldNumber = 18, + kModulusFieldNumber = 20, + kPacketSizeMplyFieldNumber = 19, + kIoUringRecvBatchSizeFieldNumber = 23, + kIoUringCqeBatchSizeFieldNumber = 24, + kIoUringFieldNumber = 22, + kReconcileBeforePollFieldNumber = 41, + kS3SkipBucketProbeFieldNumber = 106, + kUplinkInterfacesFieldNumber = 222, + kCapturePathFieldNumber = 51, + kTopicFieldNumber = 80, + kKafkaSchemaUrlFieldNumber = 81, + kKafkaCompressionFieldNumber = 83, + kS3EndpointFieldNumber = 100, + kS3RegionFieldNumber = 101, + kS3BucketFieldNumber = 102, + kS3PrefixFieldNumber = 103, + kS3AccessKeyFieldNumber = 104, + kS3SecretKeyFieldNumber = 105, + kHostnameFieldNumber = 130, + kLocationFieldNumber = 131, + kLabelFieldNumber = 132, + kTagFieldNumber = 133, + kDaemonVersionFieldNumber = 134, + kPyroscopeUrlFieldNumber = 170, + kDockerSocketPathFieldNumber = 202, + kLldpdSocketPathFieldNumber = 211, + kLldpdVersionHintFieldNumber = 212, + kAsnDbPathFieldNumber = 241, + kReconcileFrequencyFieldNumber = 40, + kKafkaProduceTimeoutFieldNumber = 82, + kS3FlushIntervalFieldNumber = 111, + kS3UploadBackoffCapFieldNumber = 115, + kAsnRefreshIntervalFieldNumber = 242, + kLocalityRefreshIntervalFieldNumber = 246, + kWriteFilesFieldNumber = 50, + kDestWriteFilesFieldNumber = 52, + kDebugLevelFieldNumber = 53, + kEnvelopeFlushThresholdBytesFieldNumber = 64, + kEnvelopeFlushThresholdRowsFieldNumber = 65, + kS3ParquetFlushThresholdBytesFieldNumber = 110, + kS3FlushJitterPctFieldNumber = 112, + kS3FlushThresholdJitterPctFieldNumber = 113, + kS3UploadMaxAttemptsFieldNumber = 114, + kIpv4TtlFieldNumber = 150, + kIpv6HopLimitFieldNumber = 151, + kGrpcPortFieldNumber = 160, + kPyroscopeSampleHzFieldNumber = 172, + kPyroscopeUploadIntervalSecFieldNumber = 173, + kResolveContainerIdFieldNumber = 200, + kEnrichContainerEnableFieldNumber = 201, + kEnrichLldpEnableFieldNumber = 210, + kEnrichNicEnableFieldNumber = 220, + kUplinkCountFieldNumber = 221, + kPopulateNsidFieldNumber = 230, + kEnrichAsnEnableFieldNumber = 240, + kEnrichLocalityEnableFieldNumber = 245, }; - // string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { - void clear_s3_endpoint() ; - [[nodiscard]] const ::std::string& s3_endpoint() const; + // string dest = 60 [json_name = "dest", (.buf.validate.field) = { + void clear_dest() ; + [[nodiscard]] const ::std::string& dest() const; template - void set_s3_endpoint(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_s3_endpoint(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_endpoint(); - void set_allocated_s3_endpoint(::std::string* PROTOBUF_NULLABLE value); + void set_dest(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_dest(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dest(); + void set_allocated_dest(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_s3_endpoint() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_s3_endpoint(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_endpoint(); + const ::std::string& _internal_dest() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_dest(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_dest(); public: - // string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { - void clear_s3_prefix() ; - [[nodiscard]] const ::std::string& s3_prefix() const; + // string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { + void clear_marshal_to() ; + [[nodiscard]] const ::std::string& marshal_to() const; template - void set_s3_prefix(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_s3_prefix(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_prefix(); - void set_allocated_s3_prefix(::std::string* PROTOBUF_NULLABLE value); + void set_marshal_to(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_marshal_to(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_marshal_to(); + void set_allocated_marshal_to(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_s3_prefix() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_s3_prefix(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_prefix(); + const ::std::string& _internal_marshal_to() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_marshal_to(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_marshal_to(); public: - // string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { - void clear_s3_secret_key() ; - [[nodiscard]] const ::std::string& s3_secret_key() const; + // string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { + void clear_csv_columns() ; + [[nodiscard]] const ::std::string& csv_columns() const; template - void set_s3_secret_key(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_s3_secret_key(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_secret_key(); - void set_allocated_s3_secret_key(::std::string* PROTOBUF_NULLABLE value); + void set_csv_columns(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_csv_columns(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_csv_columns(); + void set_allocated_csv_columns(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_s3_secret_key() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_s3_secret_key(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_secret_key(); + const ::std::string& _internal_csv_columns() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_csv_columns(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_csv_columns(); public: - // string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { - void clear_s3_region() ; - [[nodiscard]] const ::std::string& s3_region() const; + // string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { + void clear_xtcp_proto_file() ; + [[nodiscard]] const ::std::string& xtcp_proto_file() const; template - void set_s3_region(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_s3_region(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_region(); - void set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE value); + void set_xtcp_proto_file(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_xtcp_proto_file(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_xtcp_proto_file(); + void set_allocated_xtcp_proto_file(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_s3_region() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_s3_region(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_region(); + const ::std::string& _internal_xtcp_proto_file() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_xtcp_proto_file(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_xtcp_proto_file(); public: - // string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { + // string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { void clear_pyroscope_app_name() ; [[nodiscard]] const ::std::string& pyroscope_app_name() const; template @@ -2274,7 +2274,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_pyroscope_app_name(); public: - // .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { + // .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { [[nodiscard]] bool has_poll_frequency() const; void clear_poll_frequency() ; @@ -2290,7 +2290,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_poll_frequency(); public: - // .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { + // .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { [[nodiscard]] bool has_poll_timeout() const; void clear_poll_timeout() ; @@ -2305,6 +2305,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: const ::google::protobuf::Duration& _internal_poll_timeout() const; ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_poll_timeout(); + public: + // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { + [[nodiscard]] bool has_enabled_deserializers() + const; + void clear_enabled_deserializers() ; + [[nodiscard]] const ::xtcp_config::v1::EnabledDeserializers& enabled_deserializers() const; + [[nodiscard]] ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE release_enabled_deserializers(); + ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL mutable_enabled_deserializers(); + void set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value); + ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE unsafe_arena_release_enabled_deserializers(); + + private: + const ::xtcp_config::v1::EnabledDeserializers& _internal_enabled_deserializers() const; + ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL _internal_mutable_enabled_deserializers(); + public: // uint64 nl_timeout_milliseconds = 10 [json_name = "nlTimeoutMilliseconds", (.buf.validate.field) = { void clear_nl_timeout_milliseconds() ; @@ -2316,7 +2332,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_nl_timeout_milliseconds(::uint64_t value); public: - // uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { + // uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { void clear_max_loops() ; [[nodiscard]] ::uint64_t max_loops() const; void set_max_loops(::uint64_t value); @@ -2326,7 +2342,17 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_max_loops(::uint64_t value); public: - // uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { + // uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { + void clear_poll_jitter_pct() ; + [[nodiscard]] ::uint32_t poll_jitter_pct() const; + void set_poll_jitter_pct(::uint32_t value); + + private: + ::uint32_t _internal_poll_jitter_pct() const; + void _internal_set_poll_jitter_pct(::uint32_t value); + + public: + // uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { void clear_netlinkers() ; [[nodiscard]] ::uint32_t netlinkers() const; void set_netlinkers(::uint32_t value); @@ -2336,7 +2362,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_netlinkers(::uint32_t value); public: - // uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { + // uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { void clear_netlinkers_done_chan_size() ; [[nodiscard]] ::uint32_t netlinkers_done_chan_size() const; void set_netlinkers_done_chan_size(::uint32_t value); @@ -2346,7 +2372,17 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_netlinkers_done_chan_size(::uint32_t value); public: - // uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { + // uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { + void clear_nlmsg_seq() ; + [[nodiscard]] ::uint32_t nlmsg_seq() const; + void set_nlmsg_seq(::uint32_t value); + + private: + ::uint32_t _internal_nlmsg_seq() const; + void _internal_set_nlmsg_seq(::uint32_t value); + + public: + // uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { void clear_packet_size() ; [[nodiscard]] ::uint64_t packet_size() const; void set_packet_size(::uint64_t value); @@ -2356,17 +2392,17 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_packet_size(::uint64_t value); public: - // uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { - void clear_nlmsg_seq() ; - [[nodiscard]] ::uint32_t nlmsg_seq() const; - void set_nlmsg_seq(::uint32_t value); + // uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { + void clear_modulus() ; + [[nodiscard]] ::uint64_t modulus() const; + void set_modulus(::uint64_t value); private: - ::uint32_t _internal_nlmsg_seq() const; - void _internal_set_nlmsg_seq(::uint32_t value); + ::uint64_t _internal_modulus() const; + void _internal_set_modulus(::uint64_t value); public: - // uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { + // uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { void clear_packet_size_mply() ; [[nodiscard]] ::uint32_t packet_size_mply() const; void set_packet_size_mply(::uint32_t value); @@ -2376,37 +2412,57 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_packet_size_mply(::uint32_t value); public: - // uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { - void clear_write_files() ; - [[nodiscard]] ::uint32_t write_files() const; - void set_write_files(::uint32_t value); + // uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { + void clear_io_uring_recv_batch_size() ; + [[nodiscard]] ::uint32_t io_uring_recv_batch_size() const; + void set_io_uring_recv_batch_size(::uint32_t value); private: - ::uint32_t _internal_write_files() const; - void _internal_set_write_files(::uint32_t value); + ::uint32_t _internal_io_uring_recv_batch_size() const; + void _internal_set_io_uring_recv_batch_size(::uint32_t value); public: - // uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { - void clear_envelope_flush_threshold_rows() ; - [[nodiscard]] ::uint32_t envelope_flush_threshold_rows() const; - void set_envelope_flush_threshold_rows(::uint32_t value); + // uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { + void clear_io_uring_cqe_batch_size() ; + [[nodiscard]] ::uint32_t io_uring_cqe_batch_size() const; + void set_io_uring_cqe_batch_size(::uint32_t value); private: - ::uint32_t _internal_envelope_flush_threshold_rows() const; - void _internal_set_envelope_flush_threshold_rows(::uint32_t value); + ::uint32_t _internal_io_uring_cqe_batch_size() const; + void _internal_set_io_uring_cqe_batch_size(::uint32_t value); public: - // uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { - void clear_dest_write_files() ; - [[nodiscard]] ::uint32_t dest_write_files() const; - void set_dest_write_files(::uint32_t value); + // bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { + void clear_io_uring() ; + [[nodiscard]] bool io_uring() const; + void set_io_uring(bool value); private: - ::uint32_t _internal_dest_write_files() const; - void _internal_set_dest_write_files(::uint32_t value); + bool _internal_io_uring() const; + void _internal_set_io_uring(bool value); + + public: + // bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; + void clear_reconcile_before_poll() ; + [[nodiscard]] bool reconcile_before_poll() const; + void set_reconcile_before_poll(bool value); + + private: + bool _internal_reconcile_before_poll() const; + void _internal_set_reconcile_before_poll(bool value); + + public: + // bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { + void clear_s3_skip_bucket_probe() ; + [[nodiscard]] bool s3_skip_bucket_probe() const; + void set_s3_skip_bucket_probe(bool value); + + private: + bool _internal_s3_skip_bucket_probe() const; + void _internal_set_s3_skip_bucket_probe(bool value); public: - // repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { + // repeated string uplink_interfaces = 222 [json_name = "uplinkInterfaces", (.buf.validate.field) = { [[nodiscard]] int uplink_interfaces_size() const; private: @@ -2433,7 +2489,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_uplink_interfaces(); public: - // string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { + // string capture_path = 51 [json_name = "capturePath", (.buf.validate.field) = { void clear_capture_path() ; [[nodiscard]] const ::std::string& capture_path() const; template @@ -2448,22 +2504,37 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_capture_path(); public: - // string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { - void clear_marshal_to() ; - [[nodiscard]] const ::std::string& marshal_to() const; + // string topic = 80 [json_name = "topic", (.buf.validate.field) = { + void clear_topic() ; + [[nodiscard]] const ::std::string& topic() const; template - void set_marshal_to(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_marshal_to(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_marshal_to(); - void set_allocated_marshal_to(::std::string* PROTOBUF_NULLABLE value); + void set_topic(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_topic(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_topic(); + void set_allocated_topic(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_marshal_to() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_marshal_to(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_marshal_to(); + const ::std::string& _internal_topic() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_topic(); + + public: + // string kafka_schema_url = 81 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { + void clear_kafka_schema_url() ; + [[nodiscard]] const ::std::string& kafka_schema_url() const; + template + void set_kafka_schema_url(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_kafka_schema_url(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_kafka_schema_url(); + void set_allocated_kafka_schema_url(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_kafka_schema_url() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_kafka_schema_url(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_kafka_schema_url(); public: - // string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { + // string kafka_compression = 83 [json_name = "kafkaCompression", (.buf.validate.field) = { void clear_kafka_compression() ; [[nodiscard]] const ::std::string& kafka_compression() const; template @@ -2478,7 +2549,37 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_kafka_compression(); public: - // string s3_bucket = 126 [json_name = "s3Bucket", (.buf.validate.field) = { + // string s3_endpoint = 100 [json_name = "s3Endpoint", (.buf.validate.field) = { + void clear_s3_endpoint() ; + [[nodiscard]] const ::std::string& s3_endpoint() const; + template + void set_s3_endpoint(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_s3_endpoint(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_endpoint(); + void set_allocated_s3_endpoint(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_s3_endpoint() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_s3_endpoint(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_endpoint(); + + public: + // string s3_region = 101 [json_name = "s3Region", (.buf.validate.field) = { + void clear_s3_region() ; + [[nodiscard]] const ::std::string& s3_region() const; + template + void set_s3_region(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_s3_region(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_region(); + void set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_s3_region() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_s3_region(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_region(); + + public: + // string s3_bucket = 102 [json_name = "s3Bucket", (.buf.validate.field) = { void clear_s3_bucket() ; [[nodiscard]] const ::std::string& s3_bucket() const; template @@ -2493,7 +2594,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_bucket(); public: - // string s3_access_key = 128 [json_name = "s3AccessKey", (.buf.validate.field) = { + // string s3_prefix = 103 [json_name = "s3Prefix", (.buf.validate.field) = { + void clear_s3_prefix() ; + [[nodiscard]] const ::std::string& s3_prefix() const; + template + void set_s3_prefix(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_s3_prefix(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_prefix(); + void set_allocated_s3_prefix(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_s3_prefix() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_s3_prefix(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_prefix(); + + public: + // string s3_access_key = 104 [json_name = "s3AccessKey", (.buf.validate.field) = { void clear_s3_access_key() ; [[nodiscard]] const ::std::string& s3_access_key() const; template @@ -2508,82 +2624,52 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_access_key(); public: - // string dest = 130 [json_name = "dest", (.buf.validate.field) = { - void clear_dest() ; - [[nodiscard]] const ::std::string& dest() const; + // string s3_secret_key = 105 [json_name = "s3SecretKey", (.buf.validate.field) = { + void clear_s3_secret_key() ; + [[nodiscard]] const ::std::string& s3_secret_key() const; template - void set_dest(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_dest(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_dest(); - void set_allocated_dest(::std::string* PROTOBUF_NULLABLE value); + void set_s3_secret_key(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_s3_secret_key(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_s3_secret_key(); + void set_allocated_s3_secret_key(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_dest() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_dest(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_dest(); - - public: - // string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { - void clear_pyroscope_url() ; - [[nodiscard]] const ::std::string& pyroscope_url() const; - template - void set_pyroscope_url(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_pyroscope_url(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_pyroscope_url(); - void set_allocated_pyroscope_url(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_pyroscope_url() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_pyroscope_url(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_pyroscope_url(); - - public: - // string topic = 140 [json_name = "topic", (.buf.validate.field) = { - void clear_topic() ; - [[nodiscard]] const ::std::string& topic() const; - template - void set_topic(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_topic(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_topic(); - void set_allocated_topic(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_topic() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_topic(); + const ::std::string& _internal_s3_secret_key() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_s3_secret_key(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_s3_secret_key(); public: - // string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { - void clear_xtcp_proto_file() ; - [[nodiscard]] const ::std::string& xtcp_proto_file() const; + // string hostname = 130 [json_name = "hostname", (.buf.validate.field) = { + void clear_hostname() ; + [[nodiscard]] const ::std::string& hostname() const; template - void set_xtcp_proto_file(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_xtcp_proto_file(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_xtcp_proto_file(); - void set_allocated_xtcp_proto_file(::std::string* PROTOBUF_NULLABLE value); + void set_hostname(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_hostname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_hostname(); + void set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_xtcp_proto_file() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_xtcp_proto_file(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_xtcp_proto_file(); + const ::std::string& _internal_hostname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_hostname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_hostname(); public: - // string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { - void clear_kafka_schema_url() ; - [[nodiscard]] const ::std::string& kafka_schema_url() const; + // string location = 131 [json_name = "location", (.buf.validate.field) = { + void clear_location() ; + [[nodiscard]] const ::std::string& location() const; template - void set_kafka_schema_url(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_kafka_schema_url(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_kafka_schema_url(); - void set_allocated_kafka_schema_url(::std::string* PROTOBUF_NULLABLE value); + void set_location(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_location(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_location(); + void set_allocated_location(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_kafka_schema_url() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_kafka_schema_url(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_kafka_schema_url(); + const ::std::string& _internal_location() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_location(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_location(); public: - // string label = 170 [json_name = "label", (.buf.validate.field) = { + // string label = 132 [json_name = "label", (.buf.validate.field) = { void clear_label() ; [[nodiscard]] const ::std::string& label() const; template @@ -2598,7 +2684,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_label(); public: - // string tag = 180 [json_name = "tag", (.buf.validate.field) = { + // string tag = 133 [json_name = "tag", (.buf.validate.field) = { void clear_tag() ; [[nodiscard]] const ::std::string& tag() const; template @@ -2613,37 +2699,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_tag(); public: - // string location = 181 [json_name = "location", (.buf.validate.field) = { - void clear_location() ; - [[nodiscard]] const ::std::string& location() const; - template - void set_location(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_location(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_location(); - void set_allocated_location(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_location() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_location(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_location(); - - public: - // string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { - void clear_hostname() ; - [[nodiscard]] const ::std::string& hostname() const; - template - void set_hostname(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_hostname(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_hostname(); - void set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_hostname() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_hostname(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_hostname(); - - public: - // string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { + // string daemon_version = 134 [json_name = "daemonVersion", (.buf.validate.field) = { void clear_daemon_version() ; [[nodiscard]] const ::std::string& daemon_version() const; template @@ -2658,22 +2714,22 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_daemon_version(); public: - // string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { - void clear_csv_columns() ; - [[nodiscard]] const ::std::string& csv_columns() const; + // string pyroscope_url = 170 [json_name = "pyroscopeUrl", (.buf.validate.field) = { + void clear_pyroscope_url() ; + [[nodiscard]] const ::std::string& pyroscope_url() const; template - void set_csv_columns(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_csv_columns(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_csv_columns(); - void set_allocated_csv_columns(::std::string* PROTOBUF_NULLABLE value); + void set_pyroscope_url(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_pyroscope_url(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_pyroscope_url(); + void set_allocated_pyroscope_url(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_csv_columns() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_csv_columns(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_csv_columns(); + const ::std::string& _internal_pyroscope_url() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_pyroscope_url(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_pyroscope_url(); public: - // string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { + // string docker_socket_path = 202 [json_name = "dockerSocketPath", (.buf.validate.field) = { void clear_docker_socket_path() ; [[nodiscard]] const ::std::string& docker_socket_path() const; template @@ -2688,7 +2744,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_docker_socket_path(); public: - // string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { + // string lldpd_socket_path = 211 [json_name = "lldpdSocketPath", (.buf.validate.field) = { void clear_lldpd_socket_path() ; [[nodiscard]] const ::std::string& lldpd_socket_path() const; template @@ -2703,7 +2759,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_lldpd_socket_path(); public: - // string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { + // string lldpd_version_hint = 212 [json_name = "lldpdVersionHint", (.buf.validate.field) = { void clear_lldpd_version_hint() ; [[nodiscard]] const ::std::string& lldpd_version_hint() const; template @@ -2718,7 +2774,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_lldpd_version_hint(); public: - // string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { + // string asn_db_path = 241 [json_name = "asnDbPath", (.buf.validate.field) = { void clear_asn_db_path() ; [[nodiscard]] const ::std::string& asn_db_path() const; template @@ -2733,7 +2789,23 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::std::string* PROTOBUF_NONNULL _internal_mutable_asn_db_path(); public: - // .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { + // .google.protobuf.Duration reconcile_frequency = 40 [json_name = "reconcileFrequency", (.buf.validate.field) = { + [[nodiscard]] bool has_reconcile_frequency() + const; + void clear_reconcile_frequency() ; + [[nodiscard]] const ::google::protobuf::Duration& reconcile_frequency() const; + [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_reconcile_frequency(); + ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_reconcile_frequency(); + void set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value); + ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_reconcile_frequency(); + + private: + const ::google::protobuf::Duration& _internal_reconcile_frequency() const; + ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_reconcile_frequency(); + + public: + // .google.protobuf.Duration kafka_produce_timeout = 82 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { [[nodiscard]] bool has_kafka_produce_timeout() const; void clear_kafka_produce_timeout() ; @@ -2749,23 +2821,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_kafka_produce_timeout(); public: - // .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { - [[nodiscard]] bool has_enabled_deserializers() - const; - void clear_enabled_deserializers() ; - [[nodiscard]] const ::xtcp_config::v1::EnabledDeserializers& enabled_deserializers() const; - [[nodiscard]] ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE release_enabled_deserializers(); - ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL mutable_enabled_deserializers(); - void set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value); - ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE unsafe_arena_release_enabled_deserializers(); - - private: - const ::xtcp_config::v1::EnabledDeserializers& _internal_enabled_deserializers() const; - ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL _internal_mutable_enabled_deserializers(); - - public: - // .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { + // .google.protobuf.Duration s3_flush_interval = 111 [json_name = "s3FlushInterval", (.buf.validate.field) = { [[nodiscard]] bool has_s3_flush_interval() const; void clear_s3_flush_interval() ; @@ -2781,7 +2837,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_s3_flush_interval(); public: - // .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { + // .google.protobuf.Duration s3_upload_backoff_cap = 115 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { [[nodiscard]] bool has_s3_upload_backoff_cap() const; void clear_s3_upload_backoff_cap() ; @@ -2797,23 +2853,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_s3_upload_backoff_cap(); public: - // .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { - [[nodiscard]] bool has_reconcile_frequency() - const; - void clear_reconcile_frequency() ; - [[nodiscard]] const ::google::protobuf::Duration& reconcile_frequency() const; - [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_reconcile_frequency(); - ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_reconcile_frequency(); - void set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value); - ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_reconcile_frequency(); - - private: - const ::google::protobuf::Duration& _internal_reconcile_frequency() const; - ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_reconcile_frequency(); - - public: - // .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; + // .google.protobuf.Duration asn_refresh_interval = 242 [json_name = "asnRefreshInterval"]; [[nodiscard]] bool has_asn_refresh_interval() const; void clear_asn_refresh_interval() ; @@ -2829,7 +2869,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_asn_refresh_interval(); public: - // .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; + // .google.protobuf.Duration locality_refresh_interval = 246 [json_name = "localityRefreshInterval"]; [[nodiscard]] bool has_locality_refresh_interval() const; void clear_locality_refresh_interval() ; @@ -2845,17 +2885,37 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_locality_refresh_interval(); public: - // uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { - void clear_modulus() ; - [[nodiscard]] ::uint64_t modulus() const; - void set_modulus(::uint64_t value); + // uint32 write_files = 50 [json_name = "writeFiles", (.buf.validate.field) = { + void clear_write_files() ; + [[nodiscard]] ::uint32_t write_files() const; + void set_write_files(::uint32_t value); private: - ::uint64_t _internal_modulus() const; - void _internal_set_modulus(::uint64_t value); + ::uint32_t _internal_write_files() const; + void _internal_set_write_files(::uint32_t value); + + public: + // uint32 dest_write_files = 52 [json_name = "destWriteFiles", (.buf.validate.field) = { + void clear_dest_write_files() ; + [[nodiscard]] ::uint32_t dest_write_files() const; + void set_dest_write_files(::uint32_t value); + + private: + ::uint32_t _internal_dest_write_files() const; + void _internal_set_dest_write_files(::uint32_t value); + + public: + // uint32 debug_level = 53 [json_name = "debugLevel", (.buf.validate.field) = { + void clear_debug_level() ; + [[nodiscard]] ::uint32_t debug_level() const; + void set_debug_level(::uint32_t value); + + private: + ::uint32_t _internal_debug_level() const; + void _internal_set_debug_level(::uint32_t value); public: - // uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { + // uint32 envelope_flush_threshold_bytes = 64 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { void clear_envelope_flush_threshold_bytes() ; [[nodiscard]] ::uint32_t envelope_flush_threshold_bytes() const; void set_envelope_flush_threshold_bytes(::uint32_t value); @@ -2865,7 +2925,17 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_envelope_flush_threshold_bytes(::uint32_t value); public: - // uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { + // uint32 envelope_flush_threshold_rows = 65 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { + void clear_envelope_flush_threshold_rows() ; + [[nodiscard]] ::uint32_t envelope_flush_threshold_rows() const; + void set_envelope_flush_threshold_rows(::uint32_t value); + + private: + ::uint32_t _internal_envelope_flush_threshold_rows() const; + void _internal_set_envelope_flush_threshold_rows(::uint32_t value); + + public: + // uint32 s3_parquet_flush_threshold_bytes = 110 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { void clear_s3_parquet_flush_threshold_bytes() ; [[nodiscard]] ::uint32_t s3_parquet_flush_threshold_bytes() const; void set_s3_parquet_flush_threshold_bytes(::uint32_t value); @@ -2875,37 +2945,37 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_s3_parquet_flush_threshold_bytes(::uint32_t value); public: - // uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { - void clear_pyroscope_sample_hz() ; - [[nodiscard]] ::uint32_t pyroscope_sample_hz() const; - void set_pyroscope_sample_hz(::uint32_t value); + // uint32 s3_flush_jitter_pct = 112 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { + void clear_s3_flush_jitter_pct() ; + [[nodiscard]] ::uint32_t s3_flush_jitter_pct() const; + void set_s3_flush_jitter_pct(::uint32_t value); private: - ::uint32_t _internal_pyroscope_sample_hz() const; - void _internal_set_pyroscope_sample_hz(::uint32_t value); + ::uint32_t _internal_s3_flush_jitter_pct() const; + void _internal_set_s3_flush_jitter_pct(::uint32_t value); public: - // uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { - void clear_pyroscope_upload_interval_sec() ; - [[nodiscard]] ::uint32_t pyroscope_upload_interval_sec() const; - void set_pyroscope_upload_interval_sec(::uint32_t value); + // uint32 s3_flush_threshold_jitter_pct = 113 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { + void clear_s3_flush_threshold_jitter_pct() ; + [[nodiscard]] ::uint32_t s3_flush_threshold_jitter_pct() const; + void set_s3_flush_threshold_jitter_pct(::uint32_t value); private: - ::uint32_t _internal_pyroscope_upload_interval_sec() const; - void _internal_set_pyroscope_upload_interval_sec(::uint32_t value); + ::uint32_t _internal_s3_flush_threshold_jitter_pct() const; + void _internal_set_s3_flush_threshold_jitter_pct(::uint32_t value); public: - // uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { - void clear_debug_level() ; - [[nodiscard]] ::uint32_t debug_level() const; - void set_debug_level(::uint32_t value); + // uint32 s3_upload_max_attempts = 114 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { + void clear_s3_upload_max_attempts() ; + [[nodiscard]] ::uint32_t s3_upload_max_attempts() const; + void set_s3_upload_max_attempts(::uint32_t value); private: - ::uint32_t _internal_debug_level() const; - void _internal_set_debug_level(::uint32_t value); + ::uint32_t _internal_s3_upload_max_attempts() const; + void _internal_set_s3_upload_max_attempts(::uint32_t value); public: - // uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { + // uint32 ipv4_ttl = 150 [json_name = "ipv4Ttl", (.buf.validate.field) = { void clear_ipv4_ttl() ; [[nodiscard]] ::uint32_t ipv4_ttl() const; void set_ipv4_ttl(::uint32_t value); @@ -2915,7 +2985,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_ipv4_ttl(::uint32_t value); public: - // uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { + // uint32 ipv6_hop_limit = 151 [json_name = "ipv6HopLimit", (.buf.validate.field) = { void clear_ipv6_hop_limit() ; [[nodiscard]] ::uint32_t ipv6_hop_limit() const; void set_ipv6_hop_limit(::uint32_t value); @@ -2925,17 +2995,37 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_ipv6_hop_limit(::uint32_t value); public: - // bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { - void clear_s3_skip_bucket_probe() ; - [[nodiscard]] bool s3_skip_bucket_probe() const; - void set_s3_skip_bucket_probe(bool value); + // uint32 grpc_port = 160 [json_name = "grpcPort", (.buf.validate.field) = { + void clear_grpc_port() ; + [[nodiscard]] ::uint32_t grpc_port() const; + void set_grpc_port(::uint32_t value); private: - bool _internal_s3_skip_bucket_probe() const; - void _internal_set_s3_skip_bucket_probe(bool value); + ::uint32_t _internal_grpc_port() const; + void _internal_set_grpc_port(::uint32_t value); + + public: + // uint32 pyroscope_sample_hz = 172 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { + void clear_pyroscope_sample_hz() ; + [[nodiscard]] ::uint32_t pyroscope_sample_hz() const; + void set_pyroscope_sample_hz(::uint32_t value); + + private: + ::uint32_t _internal_pyroscope_sample_hz() const; + void _internal_set_pyroscope_sample_hz(::uint32_t value); + + public: + // uint32 pyroscope_upload_interval_sec = 173 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { + void clear_pyroscope_upload_interval_sec() ; + [[nodiscard]] ::uint32_t pyroscope_upload_interval_sec() const; + void set_pyroscope_upload_interval_sec(::uint32_t value); + + private: + ::uint32_t _internal_pyroscope_upload_interval_sec() const; + void _internal_set_pyroscope_upload_interval_sec(::uint32_t value); public: - // bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { + // bool resolve_container_id = 200 [json_name = "resolveContainerId", (.buf.validate.field) = { void clear_resolve_container_id() ; [[nodiscard]] bool resolve_container_id() const; void set_resolve_container_id(bool value); @@ -2945,97 +3035,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_resolve_container_id(bool value); public: - // bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { - void clear_io_uring() ; - [[nodiscard]] bool io_uring() const; - void set_io_uring(bool value); - - private: - bool _internal_io_uring() const; - void _internal_set_io_uring(bool value); - - public: - // bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; - void clear_reconcile_before_poll() ; - [[nodiscard]] bool reconcile_before_poll() const; - void set_reconcile_before_poll(bool value); - - private: - bool _internal_reconcile_before_poll() const; - void _internal_set_reconcile_before_poll(bool value); - - public: - // uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { - void clear_grpc_port() ; - [[nodiscard]] ::uint32_t grpc_port() const; - void set_grpc_port(::uint32_t value); - - private: - ::uint32_t _internal_grpc_port() const; - void _internal_set_grpc_port(::uint32_t value); - - public: - // uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { - void clear_io_uring_recv_batch_size() ; - [[nodiscard]] ::uint32_t io_uring_recv_batch_size() const; - void set_io_uring_recv_batch_size(::uint32_t value); - - private: - ::uint32_t _internal_io_uring_recv_batch_size() const; - void _internal_set_io_uring_recv_batch_size(::uint32_t value); - - public: - // uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { - void clear_io_uring_cqe_batch_size() ; - [[nodiscard]] ::uint32_t io_uring_cqe_batch_size() const; - void set_io_uring_cqe_batch_size(::uint32_t value); - - private: - ::uint32_t _internal_io_uring_cqe_batch_size() const; - void _internal_set_io_uring_cqe_batch_size(::uint32_t value); - - public: - // uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { - void clear_poll_jitter_pct() ; - [[nodiscard]] ::uint32_t poll_jitter_pct() const; - void set_poll_jitter_pct(::uint32_t value); - - private: - ::uint32_t _internal_poll_jitter_pct() const; - void _internal_set_poll_jitter_pct(::uint32_t value); - - public: - // uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { - void clear_s3_flush_jitter_pct() ; - [[nodiscard]] ::uint32_t s3_flush_jitter_pct() const; - void set_s3_flush_jitter_pct(::uint32_t value); - - private: - ::uint32_t _internal_s3_flush_jitter_pct() const; - void _internal_set_s3_flush_jitter_pct(::uint32_t value); - - public: - // uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { - void clear_s3_flush_threshold_jitter_pct() ; - [[nodiscard]] ::uint32_t s3_flush_threshold_jitter_pct() const; - void set_s3_flush_threshold_jitter_pct(::uint32_t value); - - private: - ::uint32_t _internal_s3_flush_threshold_jitter_pct() const; - void _internal_set_s3_flush_threshold_jitter_pct(::uint32_t value); - - public: - // uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { - void clear_s3_upload_max_attempts() ; - [[nodiscard]] ::uint32_t s3_upload_max_attempts() const; - void set_s3_upload_max_attempts(::uint32_t value); - - private: - ::uint32_t _internal_s3_upload_max_attempts() const; - void _internal_set_s3_upload_max_attempts(::uint32_t value); - - public: - // bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; + // bool enrich_container_enable = 201 [json_name = "enrichContainerEnable"]; void clear_enrich_container_enable() ; [[nodiscard]] bool enrich_container_enable() const; void set_enrich_container_enable(bool value); @@ -3045,7 +3045,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_enrich_container_enable(bool value); public: - // bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; + // bool enrich_lldp_enable = 210 [json_name = "enrichLldpEnable"]; void clear_enrich_lldp_enable() ; [[nodiscard]] bool enrich_lldp_enable() const; void set_enrich_lldp_enable(bool value); @@ -3055,7 +3055,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_enrich_lldp_enable(bool value); public: - // bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; + // bool enrich_nic_enable = 220 [json_name = "enrichNicEnable"]; void clear_enrich_nic_enable() ; [[nodiscard]] bool enrich_nic_enable() const; void set_enrich_nic_enable(bool value); @@ -3065,17 +3065,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_enrich_nic_enable(bool value); public: - // bool populate_nsid = 238 [json_name = "populateNsid"]; - void clear_populate_nsid() ; - [[nodiscard]] bool populate_nsid() const; - void set_populate_nsid(bool value); - - private: - bool _internal_populate_nsid() const; - void _internal_set_populate_nsid(bool value); - - public: - // uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { + // uint32 uplink_count = 221 [json_name = "uplinkCount", (.buf.validate.field) = { void clear_uplink_count() ; [[nodiscard]] ::uint32_t uplink_count() const; void set_uplink_count(::uint32_t value); @@ -3085,7 +3075,17 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_uplink_count(::uint32_t value); public: - // bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; + // bool populate_nsid = 230 [json_name = "populateNsid"]; + void clear_populate_nsid() ; + [[nodiscard]] bool populate_nsid() const; + void set_populate_nsid(bool value); + + private: + bool _internal_populate_nsid() const; + void _internal_set_populate_nsid(bool value); + + public: + // bool enrich_asn_enable = 240 [json_name = "enrichAsnEnable"]; void clear_enrich_asn_enable() ; [[nodiscard]] bool enrich_asn_enable() const; void set_enrich_asn_enable(bool value); @@ -3095,7 +3095,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: void _internal_set_enrich_asn_enable(bool value); public: - // bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; + // bool enrich_locality_enable = 245 [json_name = "enrichLocalityEnable"]; void clear_enrich_locality_enable() ; [[nodiscard]] bool enrich_locality_enable() const; void set_enrich_locality_enable(bool value); @@ -3138,75 +3138,75 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpConfig final : public ::google: const XtcpConfig& from_msg); ::google::protobuf::internal::HasBits<3> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr s3_endpoint_; - ::google::protobuf::internal::ArenaStringPtr s3_prefix_; - ::google::protobuf::internal::ArenaStringPtr s3_secret_key_; - ::google::protobuf::internal::ArenaStringPtr s3_region_; + ::google::protobuf::internal::ArenaStringPtr dest_; + ::google::protobuf::internal::ArenaStringPtr marshal_to_; + ::google::protobuf::internal::ArenaStringPtr csv_columns_; + ::google::protobuf::internal::ArenaStringPtr xtcp_proto_file_; ::google::protobuf::internal::ArenaStringPtr pyroscope_app_name_; ::google::protobuf::Duration* PROTOBUF_NULLABLE poll_frequency_; ::google::protobuf::Duration* PROTOBUF_NULLABLE poll_timeout_; + ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE enabled_deserializers_; ::uint64_t nl_timeout_milliseconds_; ::uint64_t max_loops_; + ::uint32_t poll_jitter_pct_; ::uint32_t netlinkers_; ::uint32_t netlinkers_done_chan_size_; - ::uint64_t packet_size_; ::uint32_t nlmsg_seq_; + ::uint64_t packet_size_; + ::uint64_t modulus_; ::uint32_t packet_size_mply_; - ::uint32_t write_files_; - ::uint32_t envelope_flush_threshold_rows_; - ::uint32_t dest_write_files_; + ::uint32_t io_uring_recv_batch_size_; + ::uint32_t io_uring_cqe_batch_size_; + bool io_uring_; + bool reconcile_before_poll_; + bool s3_skip_bucket_probe_; ::google::protobuf::RepeatedPtrField<::std::string> uplink_interfaces_; ::google::protobuf::internal::ArenaStringPtr capture_path_; - ::google::protobuf::internal::ArenaStringPtr marshal_to_; + ::google::protobuf::internal::ArenaStringPtr topic_; + ::google::protobuf::internal::ArenaStringPtr kafka_schema_url_; ::google::protobuf::internal::ArenaStringPtr kafka_compression_; + ::google::protobuf::internal::ArenaStringPtr s3_endpoint_; + ::google::protobuf::internal::ArenaStringPtr s3_region_; ::google::protobuf::internal::ArenaStringPtr s3_bucket_; + ::google::protobuf::internal::ArenaStringPtr s3_prefix_; ::google::protobuf::internal::ArenaStringPtr s3_access_key_; - ::google::protobuf::internal::ArenaStringPtr dest_; - ::google::protobuf::internal::ArenaStringPtr pyroscope_url_; - ::google::protobuf::internal::ArenaStringPtr topic_; - ::google::protobuf::internal::ArenaStringPtr xtcp_proto_file_; - ::google::protobuf::internal::ArenaStringPtr kafka_schema_url_; + ::google::protobuf::internal::ArenaStringPtr s3_secret_key_; + ::google::protobuf::internal::ArenaStringPtr hostname_; + ::google::protobuf::internal::ArenaStringPtr location_; ::google::protobuf::internal::ArenaStringPtr label_; ::google::protobuf::internal::ArenaStringPtr tag_; - ::google::protobuf::internal::ArenaStringPtr location_; - ::google::protobuf::internal::ArenaStringPtr hostname_; ::google::protobuf::internal::ArenaStringPtr daemon_version_; - ::google::protobuf::internal::ArenaStringPtr csv_columns_; + ::google::protobuf::internal::ArenaStringPtr pyroscope_url_; ::google::protobuf::internal::ArenaStringPtr docker_socket_path_; ::google::protobuf::internal::ArenaStringPtr lldpd_socket_path_; ::google::protobuf::internal::ArenaStringPtr lldpd_version_hint_; ::google::protobuf::internal::ArenaStringPtr asn_db_path_; + ::google::protobuf::Duration* PROTOBUF_NULLABLE reconcile_frequency_; ::google::protobuf::Duration* PROTOBUF_NULLABLE kafka_produce_timeout_; - ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE enabled_deserializers_; ::google::protobuf::Duration* PROTOBUF_NULLABLE s3_flush_interval_; ::google::protobuf::Duration* PROTOBUF_NULLABLE s3_upload_backoff_cap_; - ::google::protobuf::Duration* PROTOBUF_NULLABLE reconcile_frequency_; ::google::protobuf::Duration* PROTOBUF_NULLABLE asn_refresh_interval_; ::google::protobuf::Duration* PROTOBUF_NULLABLE locality_refresh_interval_; - ::uint64_t modulus_; + ::uint32_t write_files_; + ::uint32_t dest_write_files_; + ::uint32_t debug_level_; ::uint32_t envelope_flush_threshold_bytes_; + ::uint32_t envelope_flush_threshold_rows_; ::uint32_t s3_parquet_flush_threshold_bytes_; - ::uint32_t pyroscope_sample_hz_; - ::uint32_t pyroscope_upload_interval_sec_; - ::uint32_t debug_level_; - ::uint32_t ipv4_ttl_; - ::uint32_t ipv6_hop_limit_; - bool s3_skip_bucket_probe_; - bool resolve_container_id_; - bool io_uring_; - bool reconcile_before_poll_; - ::uint32_t grpc_port_; - ::uint32_t io_uring_recv_batch_size_; - ::uint32_t io_uring_cqe_batch_size_; - ::uint32_t poll_jitter_pct_; ::uint32_t s3_flush_jitter_pct_; ::uint32_t s3_flush_threshold_jitter_pct_; ::uint32_t s3_upload_max_attempts_; + ::uint32_t ipv4_ttl_; + ::uint32_t ipv6_hop_limit_; + ::uint32_t grpc_port_; + ::uint32_t pyroscope_sample_hz_; + ::uint32_t pyroscope_upload_interval_sec_; + bool resolve_container_id_; bool enrich_container_enable_; bool enrich_lldp_enable_; bool enrich_nic_enable_; - bool populate_nsid_; ::uint32_t uplink_count_; + bool populate_nsid_; bool enrich_asn_enable_; bool enrich_locality_enable_; PROTOBUF_TSAN_DECLARE_MEMBER @@ -5706,7 +5706,7 @@ inline void SetEnvelopeFlushResponse::set_allocated_config(::xtcp_config::v1::Xt inline void XtcpConfig::clear_nl_timeout_milliseconds() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nl_timeout_milliseconds_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[0], 0x00000080U); + ClearHasBit(_impl_._has_bits_[0], 0x00000100U); } inline ::uint64_t XtcpConfig::nl_timeout_milliseconds() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.nl_timeout_milliseconds) @@ -5714,7 +5714,7 @@ inline ::uint64_t XtcpConfig::nl_timeout_milliseconds() const { } inline void XtcpConfig::set_nl_timeout_milliseconds(::uint64_t value) { _internal_set_nl_timeout_milliseconds(value); - SetHasBit(_impl_._has_bits_[0], 0x00000080U); + SetHasBit(_impl_._has_bits_[0], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.nl_timeout_milliseconds) } inline ::uint64_t XtcpConfig::_internal_nl_timeout_milliseconds() const { @@ -5726,7 +5726,7 @@ inline void XtcpConfig::_internal_set_nl_timeout_milliseconds(::uint64_t value) _impl_.nl_timeout_milliseconds_ = value; } -// .google.protobuf.Duration poll_frequency = 20 [json_name = "pollFrequency", (.buf.validate.field) = { +// .google.protobuf.Duration poll_frequency = 11 [json_name = "pollFrequency", (.buf.validate.field) = { inline bool XtcpConfig::has_poll_frequency() const { bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); PROTOBUF_ASSUME(!value || _impl_.poll_frequency_ != nullptr); @@ -5819,7 +5819,7 @@ inline void XtcpConfig::set_allocated_poll_frequency(::google::protobuf::Duratio // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.poll_frequency) } -// .google.protobuf.Duration poll_timeout = 30 [json_name = "pollTimeout", (.buf.validate.field) = { +// .google.protobuf.Duration poll_timeout = 12 [json_name = "pollTimeout", (.buf.validate.field) = { inline bool XtcpConfig::has_poll_timeout() const { bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U); PROTOBUF_ASSUME(!value || _impl_.poll_timeout_ != nullptr); @@ -5912,11 +5912,35 @@ inline void XtcpConfig::set_allocated_poll_timeout(::google::protobuf::Duration* // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.poll_timeout) } -// uint64 max_loops = 40 [json_name = "maxLoops", (.buf.validate.field) = { +// uint32 poll_jitter_pct = 13 [json_name = "pollJitterPct", (.buf.validate.field) = { +inline void XtcpConfig::clear_poll_jitter_pct() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.poll_jitter_pct_ = 0u; + ClearHasBit(_impl_._has_bits_[0], 0x00000400U); +} +inline ::uint32_t XtcpConfig::poll_jitter_pct() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.poll_jitter_pct) + return _internal_poll_jitter_pct(); +} +inline void XtcpConfig::set_poll_jitter_pct(::uint32_t value) { + _internal_set_poll_jitter_pct(value); + SetHasBit(_impl_._has_bits_[0], 0x00000400U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.poll_jitter_pct) +} +inline ::uint32_t XtcpConfig::_internal_poll_jitter_pct() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.poll_jitter_pct_; +} +inline void XtcpConfig::_internal_set_poll_jitter_pct(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.poll_jitter_pct_ = value; +} + +// uint64 max_loops = 14 [json_name = "maxLoops", (.buf.validate.field) = { inline void XtcpConfig::clear_max_loops() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.max_loops_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[0], 0x00000100U); + ClearHasBit(_impl_._has_bits_[0], 0x00000200U); } inline ::uint64_t XtcpConfig::max_loops() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.max_loops) @@ -5924,7 +5948,7 @@ inline ::uint64_t XtcpConfig::max_loops() const { } inline void XtcpConfig::set_max_loops(::uint64_t value) { _internal_set_max_loops(value); - SetHasBit(_impl_._has_bits_[0], 0x00000100U); + SetHasBit(_impl_._has_bits_[0], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.max_loops) } inline ::uint64_t XtcpConfig::_internal_max_loops() const { @@ -5936,11 +5960,11 @@ inline void XtcpConfig::_internal_set_max_loops(::uint64_t value) { _impl_.max_loops_ = value; } -// uint32 netlinkers = 50 [json_name = "netlinkers", (.buf.validate.field) = { +// uint32 netlinkers = 15 [json_name = "netlinkers", (.buf.validate.field) = { inline void XtcpConfig::clear_netlinkers() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.netlinkers_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00000200U); + ClearHasBit(_impl_._has_bits_[0], 0x00000800U); } inline ::uint32_t XtcpConfig::netlinkers() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.netlinkers) @@ -5948,7 +5972,7 @@ inline ::uint32_t XtcpConfig::netlinkers() const { } inline void XtcpConfig::set_netlinkers(::uint32_t value) { _internal_set_netlinkers(value); - SetHasBit(_impl_._has_bits_[0], 0x00000200U); + SetHasBit(_impl_._has_bits_[0], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.netlinkers) } inline ::uint32_t XtcpConfig::_internal_netlinkers() const { @@ -5960,11 +5984,11 @@ inline void XtcpConfig::_internal_set_netlinkers(::uint32_t value) { _impl_.netlinkers_ = value; } -// uint32 netlinkers_done_chan_size = 51 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { +// uint32 netlinkers_done_chan_size = 16 [json_name = "netlinkersDoneChanSize", (.buf.validate.field) = { inline void XtcpConfig::clear_netlinkers_done_chan_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.netlinkers_done_chan_size_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00000400U); + ClearHasBit(_impl_._has_bits_[0], 0x00001000U); } inline ::uint32_t XtcpConfig::netlinkers_done_chan_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.netlinkers_done_chan_size) @@ -5972,7 +5996,7 @@ inline ::uint32_t XtcpConfig::netlinkers_done_chan_size() const { } inline void XtcpConfig::set_netlinkers_done_chan_size(::uint32_t value) { _internal_set_netlinkers_done_chan_size(value); - SetHasBit(_impl_._has_bits_[0], 0x00000400U); + SetHasBit(_impl_._has_bits_[0], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.netlinkers_done_chan_size) } inline ::uint32_t XtcpConfig::_internal_netlinkers_done_chan_size() const { @@ -5984,11 +6008,11 @@ inline void XtcpConfig::_internal_set_netlinkers_done_chan_size(::uint32_t value _impl_.netlinkers_done_chan_size_ = value; } -// uint32 nlmsg_seq = 60 [json_name = "nlmsgSeq", (.buf.validate.field) = { +// uint32 nlmsg_seq = 17 [json_name = "nlmsgSeq", (.buf.validate.field) = { inline void XtcpConfig::clear_nlmsg_seq() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.nlmsg_seq_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00001000U); + ClearHasBit(_impl_._has_bits_[0], 0x00002000U); } inline ::uint32_t XtcpConfig::nlmsg_seq() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.nlmsg_seq) @@ -5996,7 +6020,7 @@ inline ::uint32_t XtcpConfig::nlmsg_seq() const { } inline void XtcpConfig::set_nlmsg_seq(::uint32_t value) { _internal_set_nlmsg_seq(value); - SetHasBit(_impl_._has_bits_[0], 0x00001000U); + SetHasBit(_impl_._has_bits_[0], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.nlmsg_seq) } inline ::uint32_t XtcpConfig::_internal_nlmsg_seq() const { @@ -6008,11 +6032,11 @@ inline void XtcpConfig::_internal_set_nlmsg_seq(::uint32_t value) { _impl_.nlmsg_seq_ = value; } -// uint64 packet_size = 70 [json_name = "packetSize", (.buf.validate.field) = { +// uint64 packet_size = 18 [json_name = "packetSize", (.buf.validate.field) = { inline void XtcpConfig::clear_packet_size() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.packet_size_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[0], 0x00000800U); + ClearHasBit(_impl_._has_bits_[0], 0x00004000U); } inline ::uint64_t XtcpConfig::packet_size() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.packet_size) @@ -6020,7 +6044,7 @@ inline ::uint64_t XtcpConfig::packet_size() const { } inline void XtcpConfig::set_packet_size(::uint64_t value) { _internal_set_packet_size(value); - SetHasBit(_impl_._has_bits_[0], 0x00000800U); + SetHasBit(_impl_._has_bits_[0], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.packet_size) } inline ::uint64_t XtcpConfig::_internal_packet_size() const { @@ -6032,11 +6056,11 @@ inline void XtcpConfig::_internal_set_packet_size(::uint64_t value) { _impl_.packet_size_ = value; } -// uint32 packet_size_mply = 80 [json_name = "packetSizeMply", (.buf.validate.field) = { +// uint32 packet_size_mply = 19 [json_name = "packetSizeMply", (.buf.validate.field) = { inline void XtcpConfig::clear_packet_size_mply() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.packet_size_mply_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00002000U); + ClearHasBit(_impl_._has_bits_[0], 0x00010000U); } inline ::uint32_t XtcpConfig::packet_size_mply() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.packet_size_mply) @@ -6044,7 +6068,7 @@ inline ::uint32_t XtcpConfig::packet_size_mply() const { } inline void XtcpConfig::set_packet_size_mply(::uint32_t value) { _internal_set_packet_size_mply(value); - SetHasBit(_impl_._has_bits_[0], 0x00002000U); + SetHasBit(_impl_._has_bits_[0], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.packet_size_mply) } inline ::uint32_t XtcpConfig::_internal_packet_size_mply() const { @@ -6056,995 +6080,762 @@ inline void XtcpConfig::_internal_set_packet_size_mply(::uint32_t value) { _impl_.packet_size_mply_ = value; } -// uint32 write_files = 90 [json_name = "writeFiles", (.buf.validate.field) = { -inline void XtcpConfig::clear_write_files() { +// uint64 modulus = 20 [json_name = "modulus", (.buf.validate.field) = { +inline void XtcpConfig::clear_modulus() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.write_files_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00004000U); + _impl_.modulus_ = ::uint64_t{0u}; + ClearHasBit(_impl_._has_bits_[0], 0x00008000U); } -inline ::uint32_t XtcpConfig::write_files() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.write_files) - return _internal_write_files(); +inline ::uint64_t XtcpConfig::modulus() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.modulus) + return _internal_modulus(); } -inline void XtcpConfig::set_write_files(::uint32_t value) { - _internal_set_write_files(value); - SetHasBit(_impl_._has_bits_[0], 0x00004000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.write_files) +inline void XtcpConfig::set_modulus(::uint64_t value) { + _internal_set_modulus(value); + SetHasBit(_impl_._has_bits_[0], 0x00008000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.modulus) } -inline ::uint32_t XtcpConfig::_internal_write_files() const { +inline ::uint64_t XtcpConfig::_internal_modulus() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.write_files_; + return _impl_.modulus_; } -inline void XtcpConfig::_internal_set_write_files(::uint32_t value) { +inline void XtcpConfig::_internal_set_modulus(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.write_files_ = value; + _impl_.modulus_ = value; } -// string capture_path = 100 [json_name = "capturePath", (.buf.validate.field) = { -inline void XtcpConfig::clear_capture_path() { +// .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 21 [json_name = "enabledDeserializers", (.buf.validate.field) = { +inline bool XtcpConfig::has_enabled_deserializers() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U); + PROTOBUF_ASSUME(!value || _impl_.enabled_deserializers_ != nullptr); + return value; +} +inline void XtcpConfig::clear_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.capture_path_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00040000U); + if (_impl_.enabled_deserializers_ != nullptr) _impl_.enabled_deserializers_->Clear(); + ClearHasBit(_impl_._has_bits_[0], 0x00000080U); } -inline const ::std::string& XtcpConfig::capture_path() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.capture_path) - return _internal_capture_path(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_capture_path(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00040000U); - _impl_.capture_path_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.capture_path) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_capture_path() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00040000U); - ::std::string* _s = _internal_mutable_capture_path(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.capture_path) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_capture_path() const { +inline const ::xtcp_config::v1::EnabledDeserializers& XtcpConfig::_internal_enabled_deserializers() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.capture_path_.Get(); -} -inline void XtcpConfig::_internal_set_capture_path(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.capture_path_.Set(value, GetArena()); + const ::xtcp_config::v1::EnabledDeserializers* p = _impl_.enabled_deserializers_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::xtcp_config::v1::EnabledDeserializers>(&::xtcp_config::v1::EnabledDeserializers_globals_); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_capture_path() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.capture_path_.Mutable( GetArena()); +inline const ::xtcp_config::v1::EnabledDeserializers& XtcpConfig::enabled_deserializers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enabled_deserializers) + return _internal_enabled_deserializers(); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_capture_path() { +inline void XtcpConfig::unsafe_arena_set_allocated_enabled_deserializers( + ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.capture_path) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00040000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00040000U); - auto* released = _impl_.capture_path_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.capture_path_.Set("", GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.enabled_deserializers_); } - return released; -} -inline void XtcpConfig::set_allocated_capture_path(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00040000U); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00040000U); - } - _impl_.capture_path_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.capture_path_.IsDefault()) { - _impl_.capture_path_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[0], 0x00000080U); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.capture_path) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.enabled_deserializers) } - -// uint64 modulus = 110 [json_name = "modulus", (.buf.validate.field) = { -inline void XtcpConfig::clear_modulus() { +inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::release_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.modulus_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00002000U); -} -inline ::uint64_t XtcpConfig::modulus() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.modulus) - return _internal_modulus(); -} -inline void XtcpConfig::set_modulus(::uint64_t value) { - _internal_set_modulus(value); - SetHasBit(_impl_._has_bits_[1], 0x00002000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.modulus) -} -inline ::uint64_t XtcpConfig::_internal_modulus() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.modulus_; + + ClearHasBit(_impl_._has_bits_[0], 0x00000080U); + ::xtcp_config::v1::EnabledDeserializers* released = _impl_.enabled_deserializers_; + _impl_.enabled_deserializers_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline void XtcpConfig::_internal_set_modulus(::uint64_t value) { +inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.modulus_ = value; -} + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.enabled_deserializers) -// string marshal_to = 120 [json_name = "marshalTo", (.buf.validate.field) = { -inline void XtcpConfig::clear_marshal_to() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.marshal_to_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00080000U); -} -inline const ::std::string& XtcpConfig::marshal_to() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.marshal_to) - return _internal_marshal_to(); + ClearHasBit(_impl_._has_bits_[0], 0x00000080U); + ::xtcp_config::v1::EnabledDeserializers* temp = _impl_.enabled_deserializers_; + _impl_.enabled_deserializers_ = nullptr; + return temp; } -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_marshal_to(Arg_&& arg, Args_... args) { +inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_enabled_deserializers() { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00080000U); - _impl_.marshal_to_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.marshal_to) + if (_impl_.enabled_deserializers_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::xtcp_config::v1::EnabledDeserializers>(GetArena()); + _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(p); + } + return _impl_.enabled_deserializers_; } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_marshal_to() +inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::mutable_enabled_deserializers() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00080000U); - ::std::string* _s = _internal_mutable_marshal_to(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.marshal_to) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_marshal_to() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.marshal_to_.Get(); -} -inline void XtcpConfig::_internal_set_marshal_to(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.marshal_to_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_marshal_to() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.marshal_to_.Mutable( GetArena()); + SetHasBit(_impl_._has_bits_[0], 0x00000080U); + ::xtcp_config::v1::EnabledDeserializers* _msg = _internal_mutable_enabled_deserializers(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.enabled_deserializers) + return _msg; } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_marshal_to() { +inline void XtcpConfig::set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.marshal_to) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00080000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00080000U); - auto* released = _impl_.marshal_to_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.marshal_to_.Set("", GetArena()); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.enabled_deserializers_); } - return released; -} -inline void XtcpConfig::set_allocated_marshal_to(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00080000U); + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000080U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00080000U); - } - _impl_.marshal_to_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.marshal_to_.IsDefault()) { - _impl_.marshal_to_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[0], 0x00000080U); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.marshal_to) + + _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.enabled_deserializers) } -// uint32 envelope_flush_threshold_bytes = 122 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { -inline void XtcpConfig::clear_envelope_flush_threshold_bytes() { +// bool io_uring = 22 [json_name = "ioUring", (.buf.validate.field) = { +inline void XtcpConfig::clear_io_uring() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.envelope_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + _impl_.io_uring_ = false; + ClearHasBit(_impl_._has_bits_[0], 0x00080000U); } -inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) - return _internal_envelope_flush_threshold_bytes(); +inline bool XtcpConfig::io_uring() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring) + return _internal_io_uring(); } -inline void XtcpConfig::set_envelope_flush_threshold_bytes(::uint32_t value) { - _internal_set_envelope_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00004000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) +inline void XtcpConfig::set_io_uring(bool value) { + _internal_set_io_uring(value); + SetHasBit(_impl_._has_bits_[0], 0x00080000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring) } -inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_bytes() const { +inline bool XtcpConfig::_internal_io_uring() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.envelope_flush_threshold_bytes_; + return _impl_.io_uring_; } -inline void XtcpConfig::_internal_set_envelope_flush_threshold_bytes(::uint32_t value) { +inline void XtcpConfig::_internal_set_io_uring(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.envelope_flush_threshold_bytes_ = value; + _impl_.io_uring_ = value; } -// uint32 envelope_flush_threshold_rows = 123 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { -inline void XtcpConfig::clear_envelope_flush_threshold_rows() { +// uint32 io_uring_recv_batch_size = 23 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { +inline void XtcpConfig::clear_io_uring_recv_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.envelope_flush_threshold_rows_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00008000U); + _impl_.io_uring_recv_batch_size_ = 0u; + ClearHasBit(_impl_._has_bits_[0], 0x00020000U); } -inline ::uint32_t XtcpConfig::envelope_flush_threshold_rows() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_rows) - return _internal_envelope_flush_threshold_rows(); +inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) + return _internal_io_uring_recv_batch_size(); } -inline void XtcpConfig::set_envelope_flush_threshold_rows(::uint32_t value) { - _internal_set_envelope_flush_threshold_rows(value); - SetHasBit(_impl_._has_bits_[0], 0x00008000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_rows) +inline void XtcpConfig::set_io_uring_recv_batch_size(::uint32_t value) { + _internal_set_io_uring_recv_batch_size(value); + SetHasBit(_impl_._has_bits_[0], 0x00020000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) } -inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_rows() const { +inline ::uint32_t XtcpConfig::_internal_io_uring_recv_batch_size() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.envelope_flush_threshold_rows_; + return _impl_.io_uring_recv_batch_size_; } -inline void XtcpConfig::_internal_set_envelope_flush_threshold_rows(::uint32_t value) { +inline void XtcpConfig::_internal_set_io_uring_recv_batch_size(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.envelope_flush_threshold_rows_ = value; + _impl_.io_uring_recv_batch_size_ = value; } -// string kafka_compression = 124 [json_name = "kafkaCompression", (.buf.validate.field) = { -inline void XtcpConfig::clear_kafka_compression() { +// uint32 io_uring_cqe_batch_size = 24 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { +inline void XtcpConfig::clear_io_uring_cqe_batch_size() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.kafka_compression_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00100000U); + _impl_.io_uring_cqe_batch_size_ = 0u; + ClearHasBit(_impl_._has_bits_[0], 0x00040000U); } -inline const ::std::string& XtcpConfig::kafka_compression() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.kafka_compression) - return _internal_kafka_compression(); +inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) + return _internal_io_uring_cqe_batch_size(); } -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_kafka_compression(Arg_&& arg, Args_... args) { +inline void XtcpConfig::set_io_uring_cqe_batch_size(::uint32_t value) { + _internal_set_io_uring_cqe_batch_size(value); + SetHasBit(_impl_._has_bits_[0], 0x00040000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) +} +inline ::uint32_t XtcpConfig::_internal_io_uring_cqe_batch_size() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.io_uring_cqe_batch_size_; +} +inline void XtcpConfig::_internal_set_io_uring_cqe_batch_size(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00100000U); - _impl_.kafka_compression_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.kafka_compression) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_kafka_compression() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00100000U); - ::std::string* _s = _internal_mutable_kafka_compression(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.kafka_compression) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_kafka_compression() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.kafka_compression_.Get(); -} -inline void XtcpConfig::_internal_set_kafka_compression(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.kafka_compression_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_kafka_compression() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.kafka_compression_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_kafka_compression() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.kafka_compression) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00100000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00100000U); - auto* released = _impl_.kafka_compression_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.kafka_compression_.Set("", GetArena()); - } - return released; -} -inline void XtcpConfig::set_allocated_kafka_compression(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00100000U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00100000U); - } - _impl_.kafka_compression_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.kafka_compression_.IsDefault()) { - _impl_.kafka_compression_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.kafka_compression) -} - -// string s3_endpoint = 125 [json_name = "s3Endpoint", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_endpoint() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_endpoint_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); -} -inline const ::std::string& XtcpConfig::s3_endpoint() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_endpoint) - return _internal_s3_endpoint(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_endpoint(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.s3_endpoint_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_endpoint) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_endpoint() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_s3_endpoint(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_endpoint) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_s3_endpoint() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_endpoint_.Get(); -} -inline void XtcpConfig::_internal_set_s3_endpoint(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_endpoint_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_endpoint() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_endpoint_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_endpoint() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_endpoint) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.s3_endpoint_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_endpoint_.Set("", GetArena()); - } - return released; -} -inline void XtcpConfig::set_allocated_s3_endpoint(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - _impl_.s3_endpoint_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_endpoint_.IsDefault()) { - _impl_.s3_endpoint_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_endpoint) -} - -// string s3_bucket = 126 [json_name = "s3Bucket", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_bucket() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_bucket_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00200000U); -} -inline const ::std::string& XtcpConfig::s3_bucket() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_bucket) - return _internal_s3_bucket(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_bucket(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00200000U); - _impl_.s3_bucket_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_bucket) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_bucket() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00200000U); - ::std::string* _s = _internal_mutable_s3_bucket(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_bucket) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_s3_bucket() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_bucket_.Get(); -} -inline void XtcpConfig::_internal_set_s3_bucket(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_bucket_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_bucket() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_bucket_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_bucket() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_bucket) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00200000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00200000U); - auto* released = _impl_.s3_bucket_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_bucket_.Set("", GetArena()); - } - return released; -} -inline void XtcpConfig::set_allocated_s3_bucket(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00200000U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00200000U); - } - _impl_.s3_bucket_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_bucket_.IsDefault()) { - _impl_.s3_bucket_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_bucket) + _impl_.io_uring_cqe_batch_size_ = value; } -// string s3_prefix = 127 [json_name = "s3Prefix", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_prefix() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_prefix_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); -} -inline const ::std::string& XtcpConfig::s3_prefix() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_prefix) - return _internal_s3_prefix(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_prefix(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.s3_prefix_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_prefix) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_prefix() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_s3_prefix(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_prefix) - return _s; +// .google.protobuf.Duration reconcile_frequency = 40 [json_name = "reconcileFrequency", (.buf.validate.field) = { +inline bool XtcpConfig::has_reconcile_frequency() const { + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U); + PROTOBUF_ASSUME(!value || _impl_.reconcile_frequency_ != nullptr); + return value; } -inline const ::std::string& XtcpConfig::_internal_s3_prefix() const { +inline const ::google::protobuf::Duration& XtcpConfig::_internal_reconcile_frequency() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_prefix_.Get(); -} -inline void XtcpConfig::_internal_set_s3_prefix(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_prefix_.Set(value, GetArena()); + const ::google::protobuf::Duration* p = _impl_.reconcile_frequency_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_prefix() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_prefix_.Mutable( GetArena()); +inline const ::google::protobuf::Duration& XtcpConfig::reconcile_frequency() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_frequency) + return _internal_reconcile_frequency(); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_prefix() { +inline void XtcpConfig::unsafe_arena_set_allocated_reconcile_frequency( + ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_prefix) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.s3_prefix_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_prefix_.Set("", GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reconcile_frequency_); } - return released; -} -inline void XtcpConfig::set_allocated_s3_prefix(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); + SetHasBit(_impl_._has_bits_[1], 0x00000800U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - _impl_.s3_prefix_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_prefix_.IsDefault()) { - _impl_.s3_prefix_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_prefix) -} - -// string s3_access_key = 128 [json_name = "s3AccessKey", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_access_key() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_access_key_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00400000U); -} -inline const ::std::string& XtcpConfig::s3_access_key() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_access_key) - return _internal_s3_access_key(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_access_key(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00400000U); - _impl_.s3_access_key_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_access_key) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_access_key() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00400000U); - ::std::string* _s = _internal_mutable_s3_access_key(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_access_key) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_s3_access_key() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_access_key_.Get(); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.reconcile_frequency) } -inline void XtcpConfig::_internal_set_s3_access_key(const ::std::string& value) { +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_reconcile_frequency() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_access_key_.Set(value, GetArena()); + + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* released = _impl_.reconcile_frequency_; + _impl_.reconcile_frequency_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_access_key() { +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_reconcile_frequency() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_access_key_.Mutable( GetArena()); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.reconcile_frequency) + + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* temp = _impl_.reconcile_frequency_; + _impl_.reconcile_frequency_ = nullptr; + return temp; } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_access_key() { +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_reconcile_frequency() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_access_key) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00400000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00400000U); - auto* released = _impl_.s3_access_key_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_access_key_.Set("", GetArena()); + if (_impl_.reconcile_frequency_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); + _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(p); } - return released; + return _impl_.reconcile_frequency_; } -inline void XtcpConfig::set_allocated_s3_access_key(::std::string* PROTOBUF_NULLABLE value) { +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_reconcile_frequency() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + ::google::protobuf::Duration* _msg = _internal_mutable_reconcile_frequency(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.reconcile_frequency) + return _msg; +} +inline void XtcpConfig::set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reconcile_frequency_); + } + if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00400000U); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[1], 0x00000800U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00400000U); - } - _impl_.s3_access_key_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_access_key_.IsDefault()) { - _impl_.s3_access_key_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_access_key) + + _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.reconcile_frequency) } -// string s3_secret_key = 129 [json_name = "s3SecretKey", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_secret_key() { +// bool reconcile_before_poll = 41 [json_name = "reconcileBeforePoll"]; +inline void XtcpConfig::clear_reconcile_before_poll() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_secret_key_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); -} -inline const ::std::string& XtcpConfig::s3_secret_key() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_secret_key) - return _internal_s3_secret_key(); + _impl_.reconcile_before_poll_ = false; + ClearHasBit(_impl_._has_bits_[0], 0x00100000U); } -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_secret_key(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - _impl_.s3_secret_key_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_secret_key) +inline bool XtcpConfig::reconcile_before_poll() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_before_poll) + return _internal_reconcile_before_poll(); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_secret_key() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - ::std::string* _s = _internal_mutable_s3_secret_key(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_secret_key) - return _s; +inline void XtcpConfig::set_reconcile_before_poll(bool value) { + _internal_set_reconcile_before_poll(value); + SetHasBit(_impl_._has_bits_[0], 0x00100000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.reconcile_before_poll) } -inline const ::std::string& XtcpConfig::_internal_s3_secret_key() const { +inline bool XtcpConfig::_internal_reconcile_before_poll() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_secret_key_.Get(); -} -inline void XtcpConfig::_internal_set_s3_secret_key(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_secret_key_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_secret_key() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_secret_key_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_secret_key() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_secret_key) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - auto* released = _impl_.s3_secret_key_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_secret_key_.Set("", GetArena()); - } - return released; + return _impl_.reconcile_before_poll_; } -inline void XtcpConfig::set_allocated_s3_secret_key(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::_internal_set_reconcile_before_poll(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - _impl_.s3_secret_key_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_secret_key_.IsDefault()) { - _impl_.s3_secret_key_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_secret_key) + _impl_.reconcile_before_poll_ = value; } -// uint32 s3_parquet_flush_threshold_bytes = 132 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_parquet_flush_threshold_bytes() { +// uint32 write_files = 50 [json_name = "writeFiles", (.buf.validate.field) = { +inline void XtcpConfig::clear_write_files() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_parquet_flush_threshold_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00008000U); + _impl_.write_files_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00020000U); } -inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) - return _internal_s3_parquet_flush_threshold_bytes(); +inline ::uint32_t XtcpConfig::write_files() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.write_files) + return _internal_write_files(); } -inline void XtcpConfig::set_s3_parquet_flush_threshold_bytes(::uint32_t value) { - _internal_set_s3_parquet_flush_threshold_bytes(value); - SetHasBit(_impl_._has_bits_[1], 0x00008000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) +inline void XtcpConfig::set_write_files(::uint32_t value) { + _internal_set_write_files(value); + SetHasBit(_impl_._has_bits_[1], 0x00020000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.write_files) } -inline ::uint32_t XtcpConfig::_internal_s3_parquet_flush_threshold_bytes() const { +inline ::uint32_t XtcpConfig::_internal_write_files() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_parquet_flush_threshold_bytes_; + return _impl_.write_files_; } -inline void XtcpConfig::_internal_set_s3_parquet_flush_threshold_bytes(::uint32_t value) { +inline void XtcpConfig::_internal_set_write_files(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_parquet_flush_threshold_bytes_ = value; + _impl_.write_files_ = value; } -// string s3_region = 133 [json_name = "s3Region", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_region() { +// string capture_path = 51 [json_name = "capturePath", (.buf.validate.field) = { +inline void XtcpConfig::clear_capture_path() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_region_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + _impl_.capture_path_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00800000U); } -inline const ::std::string& XtcpConfig::s3_region() const +inline const ::std::string& XtcpConfig::capture_path() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_region) - return _internal_s3_region(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.capture_path) + return _internal_capture_path(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_region(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_capture_path(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - _impl_.s3_region_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_region) + SetHasBit(_impl_._has_bits_[0], 0x00800000U); + _impl_.capture_path_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.capture_path) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_region() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_capture_path() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - ::std::string* _s = _internal_mutable_s3_region(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_region) + SetHasBit(_impl_._has_bits_[0], 0x00800000U); + ::std::string* _s = _internal_mutable_capture_path(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.capture_path) return _s; } -inline const ::std::string& XtcpConfig::_internal_s3_region() const { +inline const ::std::string& XtcpConfig::_internal_capture_path() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_region_.Get(); + return _impl_.capture_path_.Get(); } -inline void XtcpConfig::_internal_set_s3_region(const ::std::string& value) { +inline void XtcpConfig::_internal_set_capture_path(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_region_.Set(value, GetArena()); + _impl_.capture_path_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_region() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_capture_path() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.s3_region_.Mutable( GetArena()); + return _impl_.capture_path_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_region() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_capture_path() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_region) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.capture_path) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00800000U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x00000008U); - auto* released = _impl_.s3_region_.Release(); + ClearHasBit(_impl_._has_bits_[0], 0x00800000U); + auto* released = _impl_.capture_path_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.s3_region_.Set("", GetArena()); + _impl_.capture_path_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_capture_path(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000008U); + SetHasBit(_impl_._has_bits_[0], 0x00800000U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + ClearHasBit(_impl_._has_bits_[0], 0x00800000U); } - _impl_.s3_region_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_region_.IsDefault()) { - _impl_.s3_region_.Set("", GetArena()); + _impl_.capture_path_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.capture_path_.IsDefault()) { + _impl_.capture_path_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_region) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.capture_path) } -// bool s3_skip_bucket_probe = 134 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_skip_bucket_probe() { +// uint32 dest_write_files = 52 [json_name = "destWriteFiles", (.buf.validate.field) = { +inline void XtcpConfig::clear_dest_write_files() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_skip_bucket_probe_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00200000U); + _impl_.dest_write_files_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00040000U); +} +inline ::uint32_t XtcpConfig::dest_write_files() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.dest_write_files) + return _internal_dest_write_files(); +} +inline void XtcpConfig::set_dest_write_files(::uint32_t value) { + _internal_set_dest_write_files(value); + SetHasBit(_impl_._has_bits_[1], 0x00040000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.dest_write_files) +} +inline ::uint32_t XtcpConfig::_internal_dest_write_files() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.dest_write_files_; +} +inline void XtcpConfig::_internal_set_dest_write_files(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.dest_write_files_ = value; +} + +// uint32 debug_level = 53 [json_name = "debugLevel", (.buf.validate.field) = { +inline void XtcpConfig::clear_debug_level() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.debug_level_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00080000U); } -inline bool XtcpConfig::s3_skip_bucket_probe() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) - return _internal_s3_skip_bucket_probe(); +inline ::uint32_t XtcpConfig::debug_level() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.debug_level) + return _internal_debug_level(); } -inline void XtcpConfig::set_s3_skip_bucket_probe(bool value) { - _internal_set_s3_skip_bucket_probe(value); - SetHasBit(_impl_._has_bits_[1], 0x00200000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) +inline void XtcpConfig::set_debug_level(::uint32_t value) { + _internal_set_debug_level(value); + SetHasBit(_impl_._has_bits_[1], 0x00080000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.debug_level) } -inline bool XtcpConfig::_internal_s3_skip_bucket_probe() const { +inline ::uint32_t XtcpConfig::_internal_debug_level() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_skip_bucket_probe_; + return _impl_.debug_level_; } -inline void XtcpConfig::_internal_set_s3_skip_bucket_probe(bool value) { +inline void XtcpConfig::_internal_set_debug_level(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_skip_bucket_probe_ = value; + _impl_.debug_level_ = value; } -// string pyroscope_url = 136 [json_name = "pyroscopeUrl", (.buf.validate.field) = { -inline void XtcpConfig::clear_pyroscope_url() { +// string dest = 60 [json_name = "dest", (.buf.validate.field) = { +inline void XtcpConfig::clear_dest() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_url_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x01000000U); + _impl_.dest_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& XtcpConfig::pyroscope_url() const +inline const ::std::string& XtcpConfig::dest() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_url) - return _internal_pyroscope_url(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.dest) + return _internal_dest(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_pyroscope_url(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_dest(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x01000000U); - _impl_.pyroscope_url_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_url) + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.dest_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.dest) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_pyroscope_url() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_dest() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x01000000U); - ::std::string* _s = _internal_mutable_pyroscope_url(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.pyroscope_url) + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_dest(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.dest) return _s; } -inline const ::std::string& XtcpConfig::_internal_pyroscope_url() const { +inline const ::std::string& XtcpConfig::_internal_dest() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pyroscope_url_.Get(); + return _impl_.dest_.Get(); } -inline void XtcpConfig::_internal_set_pyroscope_url(const ::std::string& value) { +inline void XtcpConfig::_internal_set_dest(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_url_.Set(value, GetArena()); + _impl_.dest_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_pyroscope_url() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_dest() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.pyroscope_url_.Mutable( GetArena()); + return _impl_.dest_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_pyroscope_url() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_dest() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.pyroscope_url) - if (!CheckHasBit(_impl_._has_bits_[0], 0x01000000U)) { + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.dest) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x01000000U); - auto* released = _impl_.pyroscope_url_.Release(); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.dest_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.pyroscope_url_.Set("", GetArena()); + _impl_.dest_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_pyroscope_url(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_dest(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x01000000U); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x01000000U); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.pyroscope_url_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pyroscope_url_.IsDefault()) { - _impl_.pyroscope_url_.Set("", GetArena()); + _impl_.dest_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.dest_.IsDefault()) { + _impl_.dest_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.pyroscope_url) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.dest) } -// string pyroscope_app_name = 137 [json_name = "pyroscopeAppName", (.buf.validate.field) = { -inline void XtcpConfig::clear_pyroscope_app_name() { +// string marshal_to = 61 [json_name = "marshalTo", (.buf.validate.field) = { +inline void XtcpConfig::clear_marshal_to() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_app_name_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + _impl_.marshal_to_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline const ::std::string& XtcpConfig::pyroscope_app_name() const +inline const ::std::string& XtcpConfig::marshal_to() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_app_name) - return _internal_pyroscope_app_name(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.marshal_to) + return _internal_marshal_to(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_pyroscope_app_name(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_marshal_to(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000010U); - _impl_.pyroscope_app_name_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + _impl_.marshal_to_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.marshal_to) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_pyroscope_app_name() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_marshal_to() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000010U); - ::std::string* _s = _internal_mutable_pyroscope_app_name(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_marshal_to(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.marshal_to) return _s; } -inline const ::std::string& XtcpConfig::_internal_pyroscope_app_name() const { +inline const ::std::string& XtcpConfig::_internal_marshal_to() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pyroscope_app_name_.Get(); + return _impl_.marshal_to_.Get(); } -inline void XtcpConfig::_internal_set_pyroscope_app_name(const ::std::string& value) { +inline void XtcpConfig::_internal_set_marshal_to(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_app_name_.Set(value, GetArena()); + _impl_.marshal_to_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_pyroscope_app_name() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_marshal_to() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.pyroscope_app_name_.Mutable( GetArena()); + return _impl_.marshal_to_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_pyroscope_app_name() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_marshal_to() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.pyroscope_app_name) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) { + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.marshal_to) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x00000010U); - auto* released = _impl_.pyroscope_app_name_.Release(); + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.marshal_to_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.pyroscope_app_name_.Set("", GetArena()); + _impl_.marshal_to_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_pyroscope_app_name(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_marshal_to(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000010U); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.pyroscope_app_name_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pyroscope_app_name_.IsDefault()) { - _impl_.pyroscope_app_name_.Set("", GetArena()); + _impl_.marshal_to_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.marshal_to_.IsDefault()) { + _impl_.marshal_to_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.marshal_to) } -// uint32 pyroscope_sample_hz = 138 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { -inline void XtcpConfig::clear_pyroscope_sample_hz() { +// string csv_columns = 62 [json_name = "csvColumns", (.buf.validate.field) = { +inline void XtcpConfig::clear_csv_columns() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_sample_hz_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00010000U); + _impl_.csv_columns_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } -inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) - return _internal_pyroscope_sample_hz(); +inline const ::std::string& XtcpConfig::csv_columns() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.csv_columns) + return _internal_csv_columns(); } -inline void XtcpConfig::set_pyroscope_sample_hz(::uint32_t value) { - _internal_set_pyroscope_sample_hz(value); - SetHasBit(_impl_._has_bits_[1], 0x00010000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_csv_columns(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + _impl_.csv_columns_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.csv_columns) } -inline ::uint32_t XtcpConfig::_internal_pyroscope_sample_hz() const { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_csv_columns() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_csv_columns(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.csv_columns) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_csv_columns() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pyroscope_sample_hz_; + return _impl_.csv_columns_.Get(); } -inline void XtcpConfig::_internal_set_pyroscope_sample_hz(::uint32_t value) { +inline void XtcpConfig::_internal_set_csv_columns(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_sample_hz_ = value; + _impl_.csv_columns_.Set(value, GetArena()); } - -// uint32 pyroscope_upload_interval_sec = 139 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { -inline void XtcpConfig::clear_pyroscope_upload_interval_sec() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_csv_columns() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_upload_interval_sec_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00020000U); -} -inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) - return _internal_pyroscope_upload_interval_sec(); -} -inline void XtcpConfig::set_pyroscope_upload_interval_sec(::uint32_t value) { - _internal_set_pyroscope_upload_interval_sec(value); - SetHasBit(_impl_._has_bits_[1], 0x00020000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) + return _impl_.csv_columns_.Mutable( GetArena()); } -inline ::uint32_t XtcpConfig::_internal_pyroscope_upload_interval_sec() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pyroscope_upload_interval_sec_; +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_csv_columns() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.csv_columns) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.csv_columns_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.csv_columns_.Set("", GetArena()); + } + return released; } -inline void XtcpConfig::_internal_set_pyroscope_upload_interval_sec(::uint32_t value) { +inline void XtcpConfig::set_allocated_csv_columns(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pyroscope_upload_interval_sec_ = value; + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + _impl_.csv_columns_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.csv_columns_.IsDefault()) { + _impl_.csv_columns_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.csv_columns) } -// string dest = 130 [json_name = "dest", (.buf.validate.field) = { -inline void XtcpConfig::clear_dest() { +// string xtcp_proto_file = 63 [json_name = "xtcpProtoFile", (.buf.validate.field) = { +inline void XtcpConfig::clear_xtcp_proto_file() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.dest_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x00800000U); + _impl_.xtcp_proto_file_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } -inline const ::std::string& XtcpConfig::dest() const +inline const ::std::string& XtcpConfig::xtcp_proto_file() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.dest) - return _internal_dest(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.xtcp_proto_file) + return _internal_xtcp_proto_file(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_dest(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_xtcp_proto_file(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00800000U); - _impl_.dest_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.dest) + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + _impl_.xtcp_proto_file_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.xtcp_proto_file) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_dest() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_xtcp_proto_file() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00800000U); - ::std::string* _s = _internal_mutable_dest(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.dest) + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + ::std::string* _s = _internal_mutable_xtcp_proto_file(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.xtcp_proto_file) return _s; } -inline const ::std::string& XtcpConfig::_internal_dest() const { +inline const ::std::string& XtcpConfig::_internal_xtcp_proto_file() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.dest_.Get(); + return _impl_.xtcp_proto_file_.Get(); } -inline void XtcpConfig::_internal_set_dest(const ::std::string& value) { +inline void XtcpConfig::_internal_set_xtcp_proto_file(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.dest_.Set(value, GetArena()); + _impl_.xtcp_proto_file_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_dest() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_xtcp_proto_file() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.dest_.Mutable( GetArena()); + return _impl_.xtcp_proto_file_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_dest() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_xtcp_proto_file() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.dest) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00800000U)) { + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.xtcp_proto_file) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x00800000U); - auto* released = _impl_.dest_.Release(); + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); + auto* released = _impl_.xtcp_proto_file_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.dest_.Set("", GetArena()); + _impl_.xtcp_proto_file_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_dest(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_xtcp_proto_file(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00800000U); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00800000U); + ClearHasBit(_impl_._has_bits_[0], 0x00000008U); } - _impl_.dest_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.dest_.IsDefault()) { - _impl_.dest_.Set("", GetArena()); + _impl_.xtcp_proto_file_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.xtcp_proto_file_.IsDefault()) { + _impl_.xtcp_proto_file_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.dest) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.xtcp_proto_file) } -// uint32 dest_write_files = 135 [json_name = "destWriteFiles", (.buf.validate.field) = { -inline void XtcpConfig::clear_dest_write_files() { +// uint32 envelope_flush_threshold_bytes = 64 [json_name = "envelopeFlushThresholdBytes", (.buf.validate.field) = { +inline void XtcpConfig::clear_envelope_flush_threshold_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.dest_write_files_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00010000U); + _impl_.envelope_flush_threshold_bytes_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00100000U); } -inline ::uint32_t XtcpConfig::dest_write_files() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.dest_write_files) - return _internal_dest_write_files(); +inline ::uint32_t XtcpConfig::envelope_flush_threshold_bytes() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) + return _internal_envelope_flush_threshold_bytes(); } -inline void XtcpConfig::set_dest_write_files(::uint32_t value) { - _internal_set_dest_write_files(value); - SetHasBit(_impl_._has_bits_[0], 0x00010000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.dest_write_files) +inline void XtcpConfig::set_envelope_flush_threshold_bytes(::uint32_t value) { + _internal_set_envelope_flush_threshold_bytes(value); + SetHasBit(_impl_._has_bits_[1], 0x00100000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_bytes) } -inline ::uint32_t XtcpConfig::_internal_dest_write_files() const { +inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_bytes() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.dest_write_files_; + return _impl_.envelope_flush_threshold_bytes_; } -inline void XtcpConfig::_internal_set_dest_write_files(::uint32_t value) { +inline void XtcpConfig::_internal_set_envelope_flush_threshold_bytes(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.dest_write_files_ = value; + _impl_.envelope_flush_threshold_bytes_ = value; +} + +// uint32 envelope_flush_threshold_rows = 65 [json_name = "envelopeFlushThresholdRows", (.buf.validate.field) = { +inline void XtcpConfig::clear_envelope_flush_threshold_rows() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.envelope_flush_threshold_rows_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00200000U); +} +inline ::uint32_t XtcpConfig::envelope_flush_threshold_rows() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_rows) + return _internal_envelope_flush_threshold_rows(); +} +inline void XtcpConfig::set_envelope_flush_threshold_rows(::uint32_t value) { + _internal_set_envelope_flush_threshold_rows(value); + SetHasBit(_impl_._has_bits_[1], 0x00200000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.envelope_flush_threshold_rows) +} +inline ::uint32_t XtcpConfig::_internal_envelope_flush_threshold_rows() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.envelope_flush_threshold_rows_; +} +inline void XtcpConfig::_internal_set_envelope_flush_threshold_rows(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.envelope_flush_threshold_rows_ = value; } -// string topic = 140 [json_name = "topic", (.buf.validate.field) = { +// string topic = 80 [json_name = "topic", (.buf.validate.field) = { inline void XtcpConfig::clear_topic() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.topic_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x02000000U); + ClearHasBit(_impl_._has_bits_[0], 0x01000000U); } inline const ::std::string& XtcpConfig::topic() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -7054,13 +6845,13 @@ inline const ::std::string& XtcpConfig::topic() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_topic(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x02000000U); + SetHasBit(_impl_._has_bits_[0], 0x01000000U); _impl_.topic_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.topic) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_topic() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x02000000U); + SetHasBit(_impl_._has_bits_[0], 0x01000000U); ::std::string* _s = _internal_mutable_topic(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.topic) return _s; @@ -7080,10 +6871,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_topic() { inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_topic() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.topic) - if (!CheckHasBit(_impl_._has_bits_[0], 0x02000000U)) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x01000000U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x02000000U); + ClearHasBit(_impl_._has_bits_[0], 0x01000000U); auto* released = _impl_.topic_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.topic_.Set("", GetArena()); @@ -7093,9 +6884,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_topic() { inline void XtcpConfig::set_allocated_topic(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x02000000U); + SetHasBit(_impl_._has_bits_[0], 0x01000000U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x02000000U); + ClearHasBit(_impl_._has_bits_[0], 0x01000000U); } _impl_.topic_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.topic_.IsDefault()) { @@ -7104,75 +6895,11 @@ inline void XtcpConfig::set_allocated_topic(::std::string* PROTOBUF_NULLABLE val // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.topic) } -// string xtcp_proto_file = 143 [json_name = "xtcpProtoFile", (.buf.validate.field) = { -inline void XtcpConfig::clear_xtcp_proto_file() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.xtcp_proto_file_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x04000000U); -} -inline const ::std::string& XtcpConfig::xtcp_proto_file() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.xtcp_proto_file) - return _internal_xtcp_proto_file(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_xtcp_proto_file(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x04000000U); - _impl_.xtcp_proto_file_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.xtcp_proto_file) -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_xtcp_proto_file() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x04000000U); - ::std::string* _s = _internal_mutable_xtcp_proto_file(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.xtcp_proto_file) - return _s; -} -inline const ::std::string& XtcpConfig::_internal_xtcp_proto_file() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.xtcp_proto_file_.Get(); -} -inline void XtcpConfig::_internal_set_xtcp_proto_file(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.xtcp_proto_file_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_xtcp_proto_file() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.xtcp_proto_file_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_xtcp_proto_file() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.xtcp_proto_file) - if (!CheckHasBit(_impl_._has_bits_[0], 0x04000000U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x04000000U); - auto* released = _impl_.xtcp_proto_file_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.xtcp_proto_file_.Set("", GetArena()); - } - return released; -} -inline void XtcpConfig::set_allocated_xtcp_proto_file(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x04000000U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x04000000U); - } - _impl_.xtcp_proto_file_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.xtcp_proto_file_.IsDefault()) { - _impl_.xtcp_proto_file_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.xtcp_proto_file) -} - -// string kafka_schema_url = 145 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { +// string kafka_schema_url = 81 [json_name = "kafkaSchemaUrl", (.buf.validate.field) = { inline void XtcpConfig::clear_kafka_schema_url() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.kafka_schema_url_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], 0x08000000U); + ClearHasBit(_impl_._has_bits_[0], 0x02000000U); } inline const ::std::string& XtcpConfig::kafka_schema_url() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -7182,13 +6909,13 @@ inline const ::std::string& XtcpConfig::kafka_schema_url() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_kafka_schema_url(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x08000000U); + SetHasBit(_impl_._has_bits_[0], 0x02000000U); _impl_.kafka_schema_url_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.kafka_schema_url) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_kafka_schema_url() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x08000000U); + SetHasBit(_impl_._has_bits_[0], 0x02000000U); ::std::string* _s = _internal_mutable_kafka_schema_url(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.kafka_schema_url) return _s; @@ -7208,10 +6935,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_kafka_schem inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_kafka_schema_url() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.kafka_schema_url) - if (!CheckHasBit(_impl_._has_bits_[0], 0x08000000U)) { + if (!CheckHasBit(_impl_._has_bits_[0], 0x02000000U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x08000000U); + ClearHasBit(_impl_._has_bits_[0], 0x02000000U); auto* released = _impl_.kafka_schema_url_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.kafka_schema_url_.Set("", GetArena()); @@ -7221,9 +6948,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_kafka_schema_url() { inline void XtcpConfig::set_allocated_kafka_schema_url(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x08000000U); + SetHasBit(_impl_._has_bits_[0], 0x02000000U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x08000000U); + ClearHasBit(_impl_._has_bits_[0], 0x02000000U); } _impl_.kafka_schema_url_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.kafka_schema_url_.IsDefault()) { @@ -7232,9 +6959,9 @@ inline void XtcpConfig::set_allocated_kafka_schema_url(::std::string* PROTOBUF_N // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.kafka_schema_url) } -// .google.protobuf.Duration kafka_produce_timeout = 150 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { +// .google.protobuf.Duration kafka_produce_timeout = 82 [json_name = "kafkaProduceTimeout", (.buf.validate.field) = { inline bool XtcpConfig::has_kafka_produce_timeout() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U); PROTOBUF_ASSUME(!value || _impl_.kafka_produce_timeout_ != nullptr); return value; } @@ -7255,16 +6982,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_kafka_produce_timeout( } _impl_.kafka_produce_timeout_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00001000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_kafka_produce_timeout() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); ::google::protobuf::Duration* released = _impl_.kafka_produce_timeout_; _impl_.kafka_produce_timeout_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -7284,7 +7011,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); ::google::protobuf::Duration* temp = _impl_.kafka_produce_timeout_; _impl_.kafka_produce_timeout_ = nullptr; return temp; @@ -7299,512 +7026,728 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_kafka_produce_timeout() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00001000U); ::google::protobuf::Duration* _msg = _internal_mutable_kafka_produce_timeout(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) return _msg; } -inline void XtcpConfig::set_allocated_kafka_produce_timeout(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline void XtcpConfig::set_allocated_kafka_produce_timeout(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.kafka_produce_timeout_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[1], 0x00001000U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + } + + _impl_.kafka_produce_timeout_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) +} + +// string kafka_compression = 83 [json_name = "kafkaCompression", (.buf.validate.field) = { +inline void XtcpConfig::clear_kafka_compression() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.kafka_compression_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x04000000U); +} +inline const ::std::string& XtcpConfig::kafka_compression() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.kafka_compression) + return _internal_kafka_compression(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_kafka_compression(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x04000000U); + _impl_.kafka_compression_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.kafka_compression) +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_kafka_compression() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x04000000U); + ::std::string* _s = _internal_mutable_kafka_compression(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.kafka_compression) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_kafka_compression() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.kafka_compression_.Get(); +} +inline void XtcpConfig::_internal_set_kafka_compression(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.kafka_compression_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_kafka_compression() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.kafka_compression_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_kafka_compression() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.kafka_produce_timeout_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.kafka_compression) + if (!CheckHasBit(_impl_._has_bits_[0], 0x04000000U)) { + return nullptr; } - + ClearHasBit(_impl_._has_bits_[0], 0x04000000U); + auto* released = _impl_.kafka_compression_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.kafka_compression_.Set("", GetArena()); + } + return released; +} +inline void XtcpConfig::set_allocated_kafka_compression(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[0], 0x04000000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[0], 0x04000000U); } - - _impl_.kafka_produce_timeout_ = reinterpret_cast<::google::protobuf::Duration*>(value); - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.kafka_produce_timeout) + _impl_.kafka_compression_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.kafka_compression_.IsDefault()) { + _impl_.kafka_compression_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.kafka_compression) } -// uint32 debug_level = 160 [json_name = "debugLevel", (.buf.validate.field) = { -inline void XtcpConfig::clear_debug_level() { +// string s3_endpoint = 100 [json_name = "s3Endpoint", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_endpoint() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.debug_level_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00040000U); + _impl_.s3_endpoint_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x08000000U); } -inline ::uint32_t XtcpConfig::debug_level() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.debug_level) - return _internal_debug_level(); +inline const ::std::string& XtcpConfig::s3_endpoint() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_endpoint) + return _internal_s3_endpoint(); } -inline void XtcpConfig::set_debug_level(::uint32_t value) { - _internal_set_debug_level(value); - SetHasBit(_impl_._has_bits_[1], 0x00040000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.debug_level) +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_endpoint(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x08000000U); + _impl_.s3_endpoint_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_endpoint) } -inline ::uint32_t XtcpConfig::_internal_debug_level() const { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_endpoint() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x08000000U); + ::std::string* _s = _internal_mutable_s3_endpoint(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_endpoint) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_s3_endpoint() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.debug_level_; + return _impl_.s3_endpoint_.Get(); } -inline void XtcpConfig::_internal_set_debug_level(::uint32_t value) { +inline void XtcpConfig::_internal_set_s3_endpoint(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.debug_level_ = value; + _impl_.s3_endpoint_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_endpoint() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.s3_endpoint_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_endpoint() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_endpoint) + if (!CheckHasBit(_impl_._has_bits_[0], 0x08000000U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x08000000U); + auto* released = _impl_.s3_endpoint_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.s3_endpoint_.Set("", GetArena()); + } + return released; +} +inline void XtcpConfig::set_allocated_s3_endpoint(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x08000000U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x08000000U); + } + _impl_.s3_endpoint_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_endpoint_.IsDefault()) { + _impl_.s3_endpoint_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_endpoint) } -// string label = 170 [json_name = "label", (.buf.validate.field) = { -inline void XtcpConfig::clear_label() { +// string s3_region = 101 [json_name = "s3Region", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_region() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.label_.ClearToEmpty(); + _impl_.s3_region_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x10000000U); } -inline const ::std::string& XtcpConfig::label() const +inline const ::std::string& XtcpConfig::s3_region() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.label) - return _internal_label(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_region) + return _internal_s3_region(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_label(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_region(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x10000000U); - _impl_.label_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.label) + _impl_.s3_region_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_region) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_label() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_region() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x10000000U); - ::std::string* _s = _internal_mutable_label(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.label) + ::std::string* _s = _internal_mutable_s3_region(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_region) return _s; } -inline const ::std::string& XtcpConfig::_internal_label() const { +inline const ::std::string& XtcpConfig::_internal_s3_region() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.label_.Get(); + return _impl_.s3_region_.Get(); } -inline void XtcpConfig::_internal_set_label(const ::std::string& value) { +inline void XtcpConfig::_internal_set_s3_region(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.label_.Set(value, GetArena()); + _impl_.s3_region_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_label() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_region() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.label_.Mutable( GetArena()); + return _impl_.s3_region_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_label() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_region() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.label) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_region) if (!CheckHasBit(_impl_._has_bits_[0], 0x10000000U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x10000000U); - auto* released = _impl_.label_.Release(); + auto* released = _impl_.s3_region_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.label_.Set("", GetArena()); + _impl_.s3_region_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_label(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_region(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x10000000U); } else { ClearHasBit(_impl_._has_bits_[0], 0x10000000U); } - _impl_.label_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.label_.IsDefault()) { - _impl_.label_.Set("", GetArena()); + _impl_.s3_region_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_region_.IsDefault()) { + _impl_.s3_region_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.label) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_region) } -// string tag = 180 [json_name = "tag", (.buf.validate.field) = { -inline void XtcpConfig::clear_tag() { +// string s3_bucket = 102 [json_name = "s3Bucket", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_bucket() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tag_.ClearToEmpty(); + _impl_.s3_bucket_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x20000000U); } -inline const ::std::string& XtcpConfig::tag() const +inline const ::std::string& XtcpConfig::s3_bucket() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.tag) - return _internal_tag(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_bucket) + return _internal_s3_bucket(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_tag(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_bucket(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x20000000U); - _impl_.tag_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.tag) + _impl_.s3_bucket_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_bucket) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_tag() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_bucket() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x20000000U); - ::std::string* _s = _internal_mutable_tag(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.tag) + ::std::string* _s = _internal_mutable_s3_bucket(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_bucket) return _s; } -inline const ::std::string& XtcpConfig::_internal_tag() const { +inline const ::std::string& XtcpConfig::_internal_s3_bucket() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tag_.Get(); + return _impl_.s3_bucket_.Get(); } -inline void XtcpConfig::_internal_set_tag(const ::std::string& value) { +inline void XtcpConfig::_internal_set_s3_bucket(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tag_.Set(value, GetArena()); + _impl_.s3_bucket_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_tag() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_bucket() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.tag_.Mutable( GetArena()); + return _impl_.s3_bucket_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_tag() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_bucket() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.tag) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_bucket) if (!CheckHasBit(_impl_._has_bits_[0], 0x20000000U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x20000000U); - auto* released = _impl_.tag_.Release(); + auto* released = _impl_.s3_bucket_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.tag_.Set("", GetArena()); + _impl_.s3_bucket_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_tag(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_bucket(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x20000000U); } else { ClearHasBit(_impl_._has_bits_[0], 0x20000000U); } - _impl_.tag_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tag_.IsDefault()) { - _impl_.tag_.Set("", GetArena()); + _impl_.s3_bucket_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_bucket_.IsDefault()) { + _impl_.s3_bucket_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.tag) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_bucket) } -// string location = 181 [json_name = "location", (.buf.validate.field) = { -inline void XtcpConfig::clear_location() { +// string s3_prefix = 103 [json_name = "s3Prefix", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.location_.ClearToEmpty(); + _impl_.s3_prefix_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x40000000U); } -inline const ::std::string& XtcpConfig::location() const +inline const ::std::string& XtcpConfig::s3_prefix() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.location) - return _internal_location(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_prefix) + return _internal_s3_prefix(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_location(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_prefix(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x40000000U); - _impl_.location_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.location) + _impl_.s3_prefix_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_prefix) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_location() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_prefix() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x40000000U); - ::std::string* _s = _internal_mutable_location(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.location) + ::std::string* _s = _internal_mutable_s3_prefix(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_prefix) return _s; } -inline const ::std::string& XtcpConfig::_internal_location() const { +inline const ::std::string& XtcpConfig::_internal_s3_prefix() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.location_.Get(); + return _impl_.s3_prefix_.Get(); } -inline void XtcpConfig::_internal_set_location(const ::std::string& value) { +inline void XtcpConfig::_internal_set_s3_prefix(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.location_.Set(value, GetArena()); + _impl_.s3_prefix_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_location() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.location_.Mutable( GetArena()); + return _impl_.s3_prefix_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_location() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_prefix() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.location) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_prefix) if (!CheckHasBit(_impl_._has_bits_[0], 0x40000000U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x40000000U); - auto* released = _impl_.location_.Release(); + auto* released = _impl_.s3_prefix_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.location_.Set("", GetArena()); + _impl_.s3_prefix_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_location(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_prefix(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x40000000U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x40000000U); - } - _impl_.location_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.location_.IsDefault()) { - _impl_.location_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[0], 0x40000000U); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.location) + _impl_.s3_prefix_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_prefix_.IsDefault()) { + _impl_.s3_prefix_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_prefix) } -// string hostname = 182 [json_name = "hostname", (.buf.validate.field) = { -inline void XtcpConfig::clear_hostname() { +// string s3_access_key = 104 [json_name = "s3AccessKey", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_access_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.hostname_.ClearToEmpty(); + _impl_.s3_access_key_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x80000000U); } -inline const ::std::string& XtcpConfig::hostname() const +inline const ::std::string& XtcpConfig::s3_access_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.hostname) - return _internal_hostname(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_access_key) + return _internal_s3_access_key(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_hostname(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_access_key(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x80000000U); - _impl_.hostname_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.hostname) + _impl_.s3_access_key_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_access_key) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_hostname() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_access_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x80000000U); - ::std::string* _s = _internal_mutable_hostname(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.hostname) + ::std::string* _s = _internal_mutable_s3_access_key(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_access_key) return _s; } -inline const ::std::string& XtcpConfig::_internal_hostname() const { +inline const ::std::string& XtcpConfig::_internal_s3_access_key() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.hostname_.Get(); + return _impl_.s3_access_key_.Get(); } -inline void XtcpConfig::_internal_set_hostname(const ::std::string& value) { +inline void XtcpConfig::_internal_set_s3_access_key(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.hostname_.Set(value, GetArena()); + _impl_.s3_access_key_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_hostname() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_access_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.hostname_.Mutable( GetArena()); + return _impl_.s3_access_key_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_hostname() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_access_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.hostname) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_access_key) if (!CheckHasBit(_impl_._has_bits_[0], 0x80000000U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x80000000U); - auto* released = _impl_.hostname_.Release(); + auto* released = _impl_.s3_access_key_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.hostname_.Set("", GetArena()); + _impl_.s3_access_key_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_access_key(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x80000000U); } else { ClearHasBit(_impl_._has_bits_[0], 0x80000000U); } - _impl_.hostname_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.hostname_.IsDefault()) { - _impl_.hostname_.Set("", GetArena()); + _impl_.s3_access_key_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_access_key_.IsDefault()) { + _impl_.s3_access_key_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.hostname) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_access_key) } -// string daemon_version = 186 [json_name = "daemonVersion", (.buf.validate.field) = { -inline void XtcpConfig::clear_daemon_version() { +// string s3_secret_key = 105 [json_name = "s3SecretKey", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_secret_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.daemon_version_.ClearToEmpty(); + _impl_.s3_secret_key_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[1], 0x00000001U); } -inline const ::std::string& XtcpConfig::daemon_version() const +inline const ::std::string& XtcpConfig::s3_secret_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.daemon_version) - return _internal_daemon_version(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_secret_key) + return _internal_s3_secret_key(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_daemon_version(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_s3_secret_key(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[1], 0x00000001U); - _impl_.daemon_version_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.daemon_version) + _impl_.s3_secret_key_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_secret_key) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_daemon_version() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_s3_secret_key() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[1], 0x00000001U); - ::std::string* _s = _internal_mutable_daemon_version(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.daemon_version) + ::std::string* _s = _internal_mutable_s3_secret_key(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_secret_key) return _s; } -inline const ::std::string& XtcpConfig::_internal_daemon_version() const { +inline const ::std::string& XtcpConfig::_internal_s3_secret_key() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.daemon_version_.Get(); + return _impl_.s3_secret_key_.Get(); } -inline void XtcpConfig::_internal_set_daemon_version(const ::std::string& value) { +inline void XtcpConfig::_internal_set_s3_secret_key(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.daemon_version_.Set(value, GetArena()); + _impl_.s3_secret_key_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_daemon_version() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_secret_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.daemon_version_.Mutable( GetArena()); + return _impl_.s3_secret_key_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_daemon_version() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_s3_secret_key() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.daemon_version) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_secret_key) if (!CheckHasBit(_impl_._has_bits_[1], 0x00000001U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[1], 0x00000001U); - auto* released = _impl_.daemon_version_.Release(); + auto* released = _impl_.s3_secret_key_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.daemon_version_.Set("", GetArena()); + _impl_.s3_secret_key_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_daemon_version(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_secret_key(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[1], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[1], 0x00000001U); } - _impl_.daemon_version_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.daemon_version_.IsDefault()) { - _impl_.daemon_version_.Set("", GetArena()); + _impl_.s3_secret_key_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.s3_secret_key_.IsDefault()) { + _impl_.s3_secret_key_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.daemon_version) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_secret_key) } -// bool resolve_container_id = 183 [json_name = "resolveContainerId", (.buf.validate.field) = { -inline void XtcpConfig::clear_resolve_container_id() { +// bool s3_skip_bucket_probe = 106 [json_name = "s3SkipBucketProbe", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_skip_bucket_probe() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.resolve_container_id_ = false; + _impl_.s3_skip_bucket_probe_ = false; + ClearHasBit(_impl_._has_bits_[0], 0x00200000U); +} +inline bool XtcpConfig::s3_skip_bucket_probe() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) + return _internal_s3_skip_bucket_probe(); +} +inline void XtcpConfig::set_s3_skip_bucket_probe(bool value) { + _internal_set_s3_skip_bucket_probe(value); + SetHasBit(_impl_._has_bits_[0], 0x00200000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_skip_bucket_probe) +} +inline bool XtcpConfig::_internal_s3_skip_bucket_probe() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.s3_skip_bucket_probe_; +} +inline void XtcpConfig::_internal_set_s3_skip_bucket_probe(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.s3_skip_bucket_probe_ = value; +} + +// uint32 s3_parquet_flush_threshold_bytes = 110 [json_name = "s3ParquetFlushThresholdBytes", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_parquet_flush_threshold_bytes() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.s3_parquet_flush_threshold_bytes_ = 0u; ClearHasBit(_impl_._has_bits_[1], 0x00400000U); } -inline bool XtcpConfig::resolve_container_id() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.resolve_container_id) - return _internal_resolve_container_id(); +inline ::uint32_t XtcpConfig::s3_parquet_flush_threshold_bytes() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) + return _internal_s3_parquet_flush_threshold_bytes(); } -inline void XtcpConfig::set_resolve_container_id(bool value) { - _internal_set_resolve_container_id(value); +inline void XtcpConfig::set_s3_parquet_flush_threshold_bytes(::uint32_t value) { + _internal_set_s3_parquet_flush_threshold_bytes(value); SetHasBit(_impl_._has_bits_[1], 0x00400000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.resolve_container_id) + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_parquet_flush_threshold_bytes) } -inline bool XtcpConfig::_internal_resolve_container_id() const { +inline ::uint32_t XtcpConfig::_internal_s3_parquet_flush_threshold_bytes() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.resolve_container_id_; + return _impl_.s3_parquet_flush_threshold_bytes_; } -inline void XtcpConfig::_internal_set_resolve_container_id(bool value) { +inline void XtcpConfig::_internal_set_s3_parquet_flush_threshold_bytes(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.resolve_container_id_ = value; + _impl_.s3_parquet_flush_threshold_bytes_ = value; } -// uint32 ipv4_ttl = 184 [json_name = "ipv4Ttl", (.buf.validate.field) = { -inline void XtcpConfig::clear_ipv4_ttl() { +// .google.protobuf.Duration s3_flush_interval = 111 [json_name = "s3FlushInterval", (.buf.validate.field) = { +inline bool XtcpConfig::has_s3_flush_interval() const { + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00002000U); + PROTOBUF_ASSUME(!value || _impl_.s3_flush_interval_ != nullptr); + return value; +} +inline const ::google::protobuf::Duration& XtcpConfig::_internal_s3_flush_interval() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::google::protobuf::Duration* p = _impl_.s3_flush_interval_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); +} +inline const ::google::protobuf::Duration& XtcpConfig::s3_flush_interval() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_interval) + return _internal_s3_flush_interval(); +} +inline void XtcpConfig::unsafe_arena_set_allocated_s3_flush_interval( + ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ipv4_ttl_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00080000U); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_flush_interval_); + } + _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00002000U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_flush_interval) } -inline ::uint32_t XtcpConfig::ipv4_ttl() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv4_ttl) - return _internal_ipv4_ttl(); +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_flush_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ::google::protobuf::Duration* released = _impl_.s3_flush_interval_; + _impl_.s3_flush_interval_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_s3_flush_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_flush_interval) + + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ::google::protobuf::Duration* temp = _impl_.s3_flush_interval_; + _impl_.s3_flush_interval_ = nullptr; + return temp; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_flush_interval() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.s3_flush_interval_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); + _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(p); + } + return _impl_.s3_flush_interval_; +} +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_flush_interval() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00002000U); + ::google::protobuf::Duration* _msg = _internal_mutable_s3_flush_interval(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_flush_interval) + return _msg; +} +inline void XtcpConfig::set_allocated_s3_flush_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_flush_interval_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[1], 0x00002000U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + } + + _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_flush_interval) +} + +// uint32 s3_flush_jitter_pct = 112 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_flush_jitter_pct() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.s3_flush_jitter_pct_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00800000U); +} +inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) + return _internal_s3_flush_jitter_pct(); } -inline void XtcpConfig::set_ipv4_ttl(::uint32_t value) { - _internal_set_ipv4_ttl(value); - SetHasBit(_impl_._has_bits_[1], 0x00080000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv4_ttl) +inline void XtcpConfig::set_s3_flush_jitter_pct(::uint32_t value) { + _internal_set_s3_flush_jitter_pct(value); + SetHasBit(_impl_._has_bits_[1], 0x00800000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) } -inline ::uint32_t XtcpConfig::_internal_ipv4_ttl() const { +inline ::uint32_t XtcpConfig::_internal_s3_flush_jitter_pct() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.ipv4_ttl_; + return _impl_.s3_flush_jitter_pct_; } -inline void XtcpConfig::_internal_set_ipv4_ttl(::uint32_t value) { +inline void XtcpConfig::_internal_set_s3_flush_jitter_pct(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ipv4_ttl_ = value; + _impl_.s3_flush_jitter_pct_ = value; } -// uint32 ipv6_hop_limit = 185 [json_name = "ipv6HopLimit", (.buf.validate.field) = { -inline void XtcpConfig::clear_ipv6_hop_limit() { +// uint32 s3_flush_threshold_jitter_pct = 113 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_flush_threshold_jitter_pct() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ipv6_hop_limit_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00100000U); + _impl_.s3_flush_threshold_jitter_pct_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x01000000U); } -inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) - return _internal_ipv6_hop_limit(); +inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) + return _internal_s3_flush_threshold_jitter_pct(); } -inline void XtcpConfig::set_ipv6_hop_limit(::uint32_t value) { - _internal_set_ipv6_hop_limit(value); - SetHasBit(_impl_._has_bits_[1], 0x00100000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) +inline void XtcpConfig::set_s3_flush_threshold_jitter_pct(::uint32_t value) { + _internal_set_s3_flush_threshold_jitter_pct(value); + SetHasBit(_impl_._has_bits_[1], 0x01000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) } -inline ::uint32_t XtcpConfig::_internal_ipv6_hop_limit() const { +inline ::uint32_t XtcpConfig::_internal_s3_flush_threshold_jitter_pct() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.ipv6_hop_limit_; + return _impl_.s3_flush_threshold_jitter_pct_; } -inline void XtcpConfig::_internal_set_ipv6_hop_limit(::uint32_t value) { +inline void XtcpConfig::_internal_set_s3_flush_threshold_jitter_pct(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ipv6_hop_limit_ = value; + _impl_.s3_flush_threshold_jitter_pct_ = value; } -// uint32 grpc_port = 190 [json_name = "grpcPort", (.buf.validate.field) = { -inline void XtcpConfig::clear_grpc_port() { +// uint32 s3_upload_max_attempts = 114 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { +inline void XtcpConfig::clear_s3_upload_max_attempts() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.grpc_port_ = 0u; + _impl_.s3_upload_max_attempts_ = 0u; ClearHasBit(_impl_._has_bits_[1], 0x02000000U); } -inline ::uint32_t XtcpConfig::grpc_port() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.grpc_port) - return _internal_grpc_port(); +inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) + return _internal_s3_upload_max_attempts(); } -inline void XtcpConfig::set_grpc_port(::uint32_t value) { - _internal_set_grpc_port(value); +inline void XtcpConfig::set_s3_upload_max_attempts(::uint32_t value) { + _internal_set_s3_upload_max_attempts(value); SetHasBit(_impl_._has_bits_[1], 0x02000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.grpc_port) + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) } -inline ::uint32_t XtcpConfig::_internal_grpc_port() const { +inline ::uint32_t XtcpConfig::_internal_s3_upload_max_attempts() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.grpc_port_; + return _impl_.s3_upload_max_attempts_; } -inline void XtcpConfig::_internal_set_grpc_port(::uint32_t value) { +inline void XtcpConfig::_internal_set_s3_upload_max_attempts(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.grpc_port_ = value; + _impl_.s3_upload_max_attempts_ = value; } -// .xtcp_config.v1.EnabledDeserializers enabled_deserializers = 200 [json_name = "enabledDeserializers", (.buf.validate.field) = { -inline bool XtcpConfig::has_enabled_deserializers() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U); - PROTOBUF_ASSUME(!value || _impl_.enabled_deserializers_ != nullptr); +// .google.protobuf.Duration s3_upload_backoff_cap = 115 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { +inline bool XtcpConfig::has_s3_upload_backoff_cap() const { + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00004000U); + PROTOBUF_ASSUME(!value || _impl_.s3_upload_backoff_cap_ != nullptr); return value; } -inline void XtcpConfig::clear_enabled_deserializers() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.enabled_deserializers_ != nullptr) _impl_.enabled_deserializers_->Clear(); - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); -} -inline const ::xtcp_config::v1::EnabledDeserializers& XtcpConfig::_internal_enabled_deserializers() const { +inline const ::google::protobuf::Duration& XtcpConfig::_internal_s3_upload_backoff_cap() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::xtcp_config::v1::EnabledDeserializers* p = _impl_.enabled_deserializers_; - return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::xtcp_config::v1::EnabledDeserializers>(&::xtcp_config::v1::EnabledDeserializers_globals_); + const ::google::protobuf::Duration* p = _impl_.s3_upload_backoff_cap_; + return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); } -inline const ::xtcp_config::v1::EnabledDeserializers& XtcpConfig::enabled_deserializers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.enabled_deserializers) - return _internal_enabled_deserializers(); +inline const ::google::protobuf::Duration& XtcpConfig::s3_upload_backoff_cap() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) + return _internal_s3_upload_backoff_cap(); } -inline void XtcpConfig::unsafe_arena_set_allocated_enabled_deserializers( - ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::unsafe_arena_set_allocated_s3_upload_backoff_cap( + ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.enabled_deserializers_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_upload_backoff_cap_); } - _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); + _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.enabled_deserializers) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) } -inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::release_enabled_deserializers() { +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); - ::xtcp_config::v1::EnabledDeserializers* released = _impl_.enabled_deserializers_; - _impl_.enabled_deserializers_ = nullptr; + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ::google::protobuf::Duration* released = _impl_.s3_upload_backoff_cap_; + _impl_.s3_upload_backoff_cap_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); @@ -7818,587 +7761,644 @@ inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::re } return released; } -inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_enabled_deserializers() { +inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.enabled_deserializers) + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); - ::xtcp_config::v1::EnabledDeserializers* temp = _impl_.enabled_deserializers_; - _impl_.enabled_deserializers_ = nullptr; + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ::google::protobuf::Duration* temp = _impl_.s3_upload_backoff_cap_; + _impl_.s3_upload_backoff_cap_ = nullptr; return temp; } -inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_enabled_deserializers() { +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_upload_backoff_cap() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.enabled_deserializers_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::xtcp_config::v1::EnabledDeserializers>(GetArena()); - _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(p); + if (_impl_.s3_upload_backoff_cap_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); + _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(p); } - return _impl_.enabled_deserializers_; + return _impl_.s3_upload_backoff_cap_; } -inline ::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NONNULL XtcpConfig::mutable_enabled_deserializers() +inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_upload_backoff_cap() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); - ::xtcp_config::v1::EnabledDeserializers* _msg = _internal_mutable_enabled_deserializers(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.enabled_deserializers) + SetHasBit(_impl_._has_bits_[1], 0x00004000U); + ::google::protobuf::Duration* _msg = _internal_mutable_s3_upload_backoff_cap(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) return _msg; } -inline void XtcpConfig::set_allocated_enabled_deserializers(::xtcp_config::v1::EnabledDeserializers* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_s3_upload_backoff_cap(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.enabled_deserializers_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_upload_backoff_cap_); } if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = value->GetArena(); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } - _impl_.enabled_deserializers_ = reinterpret_cast<::xtcp_config::v1::EnabledDeserializers*>(value); - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.enabled_deserializers) + _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) } -// bool io_uring = 210 [json_name = "ioUring", (.buf.validate.field) = { -inline void XtcpConfig::clear_io_uring() { +// string hostname = 130 [json_name = "hostname", (.buf.validate.field) = { +inline void XtcpConfig::clear_hostname() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x00800000U); + _impl_.hostname_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000002U); } -inline bool XtcpConfig::io_uring() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring) - return _internal_io_uring(); +inline const ::std::string& XtcpConfig::hostname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.hostname) + return _internal_hostname(); } -inline void XtcpConfig::set_io_uring(bool value) { - _internal_set_io_uring(value); - SetHasBit(_impl_._has_bits_[1], 0x00800000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring) +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_hostname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000002U); + _impl_.hostname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.hostname) } -inline bool XtcpConfig::_internal_io_uring() const { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_hostname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000002U); + ::std::string* _s = _internal_mutable_hostname(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.hostname) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_hostname() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.io_uring_; + return _impl_.hostname_.Get(); } -inline void XtcpConfig::_internal_set_io_uring(bool value) { +inline void XtcpConfig::_internal_set_hostname(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_ = value; + _impl_.hostname_.Set(value, GetArena()); } - -// uint32 io_uring_recv_batch_size = 211 [json_name = "ioUringRecvBatchSize", (.buf.validate.field) = { -inline void XtcpConfig::clear_io_uring_recv_batch_size() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_hostname() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_recv_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x04000000U); + return _impl_.hostname_.Mutable( GetArena()); } -inline ::uint32_t XtcpConfig::io_uring_recv_batch_size() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) - return _internal_io_uring_recv_batch_size(); +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_hostname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.hostname) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000002U); + auto* released = _impl_.hostname_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.hostname_.Set("", GetArena()); + } + return released; } -inline void XtcpConfig::set_io_uring_recv_batch_size(::uint32_t value) { - _internal_set_io_uring_recv_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x04000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_recv_batch_size) +inline void XtcpConfig::set_allocated_hostname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000002U); + } + _impl_.hostname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.hostname_.IsDefault()) { + _impl_.hostname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.hostname) } -inline ::uint32_t XtcpConfig::_internal_io_uring_recv_batch_size() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.io_uring_recv_batch_size_; + +// string location = 131 [json_name = "location", (.buf.validate.field) = { +inline void XtcpConfig::clear_location() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.location_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000004U); } -inline void XtcpConfig::_internal_set_io_uring_recv_batch_size(::uint32_t value) { +inline const ::std::string& XtcpConfig::location() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.location) + return _internal_location(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_location(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_recv_batch_size_ = value; + SetHasBit(_impl_._has_bits_[1], 0x00000004U); + _impl_.location_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.location) +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_location() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000004U); + ::std::string* _s = _internal_mutable_location(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.location) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_location() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.location_.Get(); } - -// uint32 io_uring_cqe_batch_size = 212 [json_name = "ioUringCqeBatchSize", (.buf.validate.field) = { -inline void XtcpConfig::clear_io_uring_cqe_batch_size() { +inline void XtcpConfig::_internal_set_location(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_cqe_batch_size_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x08000000U); -} -inline ::uint32_t XtcpConfig::io_uring_cqe_batch_size() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) - return _internal_io_uring_cqe_batch_size(); + _impl_.location_.Set(value, GetArena()); } -inline void XtcpConfig::set_io_uring_cqe_batch_size(::uint32_t value) { - _internal_set_io_uring_cqe_batch_size(value); - SetHasBit(_impl_._has_bits_[1], 0x08000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.io_uring_cqe_batch_size) +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_location() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.location_.Mutable( GetArena()); } -inline ::uint32_t XtcpConfig::_internal_io_uring_cqe_batch_size() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.io_uring_cqe_batch_size_; +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_location() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.location) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000004U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000004U); + auto* released = _impl_.location_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.location_.Set("", GetArena()); + } + return released; } -inline void XtcpConfig::_internal_set_io_uring_cqe_batch_size(::uint32_t value) { +inline void XtcpConfig::set_allocated_location(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.io_uring_cqe_batch_size_ = value; + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000004U); + } + _impl_.location_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.location_.IsDefault()) { + _impl_.location_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.location) } -// string csv_columns = 220 [json_name = "csvColumns", (.buf.validate.field) = { -inline void XtcpConfig::clear_csv_columns() { +// string label = 132 [json_name = "label", (.buf.validate.field) = { +inline void XtcpConfig::clear_label() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.csv_columns_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000002U); + _impl_.label_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000008U); } -inline const ::std::string& XtcpConfig::csv_columns() const +inline const ::std::string& XtcpConfig::label() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.csv_columns) - return _internal_csv_columns(); + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.label) + return _internal_label(); } template -PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_csv_columns(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_label(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000002U); - _impl_.csv_columns_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.csv_columns) + SetHasBit(_impl_._has_bits_[1], 0x00000008U); + _impl_.label_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.label) } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_csv_columns() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_label() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000002U); - ::std::string* _s = _internal_mutable_csv_columns(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.csv_columns) + SetHasBit(_impl_._has_bits_[1], 0x00000008U); + ::std::string* _s = _internal_mutable_label(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.label) return _s; } -inline const ::std::string& XtcpConfig::_internal_csv_columns() const { +inline const ::std::string& XtcpConfig::_internal_label() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.csv_columns_.Get(); + return _impl_.label_.Get(); } -inline void XtcpConfig::_internal_set_csv_columns(const ::std::string& value) { +inline void XtcpConfig::_internal_set_label(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.csv_columns_.Set(value, GetArena()); + _impl_.label_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_csv_columns() { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_label() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.csv_columns_.Mutable( GetArena()); + return _impl_.label_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_csv_columns() { +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_label() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.csv_columns) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000002U)) { + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.label) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000008U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000002U); - auto* released = _impl_.csv_columns_.Release(); + ClearHasBit(_impl_._has_bits_[1], 0x00000008U); + auto* released = _impl_.label_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.csv_columns_.Set("", GetArena()); + _impl_.label_.Set("", GetArena()); } return released; } -inline void XtcpConfig::set_allocated_csv_columns(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpConfig::set_allocated_label(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000002U); + SetHasBit(_impl_._has_bits_[1], 0x00000008U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000002U); + ClearHasBit(_impl_._has_bits_[1], 0x00000008U); } - _impl_.csv_columns_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.csv_columns_.IsDefault()) { - _impl_.csv_columns_.Set("", GetArena()); + _impl_.label_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.label_.IsDefault()) { + _impl_.label_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.csv_columns) + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.label) } -// uint32 poll_jitter_pct = 221 [json_name = "pollJitterPct", (.buf.validate.field) = { -inline void XtcpConfig::clear_poll_jitter_pct() { +// string tag = 133 [json_name = "tag", (.buf.validate.field) = { +inline void XtcpConfig::clear_tag() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.poll_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x10000000U); -} -inline ::uint32_t XtcpConfig::poll_jitter_pct() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.poll_jitter_pct) - return _internal_poll_jitter_pct(); -} -inline void XtcpConfig::set_poll_jitter_pct(::uint32_t value) { - _internal_set_poll_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x10000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.poll_jitter_pct) + _impl_.tag_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000010U); } -inline ::uint32_t XtcpConfig::_internal_poll_jitter_pct() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.poll_jitter_pct_; +inline const ::std::string& XtcpConfig::tag() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.tag) + return _internal_tag(); } -inline void XtcpConfig::_internal_set_poll_jitter_pct(::uint32_t value) { +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_tag(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.poll_jitter_pct_ = value; + SetHasBit(_impl_._has_bits_[1], 0x00000010U); + _impl_.tag_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.tag) } - -// .google.protobuf.Duration s3_flush_interval = 222 [json_name = "s3FlushInterval", (.buf.validate.field) = { -inline bool XtcpConfig::has_s3_flush_interval() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U); - PROTOBUF_ASSUME(!value || _impl_.s3_flush_interval_ != nullptr); - return value; +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_tag() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000010U); + ::std::string* _s = _internal_mutable_tag(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.tag) + return _s; } -inline const ::google::protobuf::Duration& XtcpConfig::_internal_s3_flush_interval() const { +inline const ::std::string& XtcpConfig::_internal_tag() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::google::protobuf::Duration* p = _impl_.s3_flush_interval_; - return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); + return _impl_.tag_.Get(); } -inline const ::google::protobuf::Duration& XtcpConfig::s3_flush_interval() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_interval) - return _internal_s3_flush_interval(); +inline void XtcpConfig::_internal_set_tag(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.tag_.Set(value, GetArena()); } -inline void XtcpConfig::unsafe_arena_set_allocated_s3_flush_interval( - ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_tag() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_flush_interval_); + return _impl_.tag_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_tag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.tag) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000010U)) { + return nullptr; } - _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000010U); + auto* released = _impl_.tag_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.tag_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_flush_interval) + return released; } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_flush_interval() { +inline void XtcpConfig::set_allocated_tag(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); - ::google::protobuf::Duration* released = _impl_.s3_flush_interval_; - _impl_.s3_flush_interval_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000010U); } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } + ClearHasBit(_impl_._has_bits_[1], 0x00000010U); } - return released; + _impl_.tag_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.tag_.IsDefault()) { + _impl_.tag_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.tag) } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_s3_flush_interval() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_flush_interval) - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); - ::google::protobuf::Duration* temp = _impl_.s3_flush_interval_; - _impl_.s3_flush_interval_ = nullptr; - return temp; +// string daemon_version = 134 [json_name = "daemonVersion", (.buf.validate.field) = { +inline void XtcpConfig::clear_daemon_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.daemon_version_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); } -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_flush_interval() { +inline const ::std::string& XtcpConfig::daemon_version() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.daemon_version) + return _internal_daemon_version(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_daemon_version(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.s3_flush_interval_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); - _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(p); - } - return _impl_.s3_flush_interval_; + SetHasBit(_impl_._has_bits_[1], 0x00000020U); + _impl_.daemon_version_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.daemon_version) } -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_flush_interval() +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_daemon_version() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); - ::google::protobuf::Duration* _msg = _internal_mutable_s3_flush_interval(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_flush_interval) - return _msg; + SetHasBit(_impl_._has_bits_[1], 0x00000020U); + ::std::string* _s = _internal_mutable_daemon_version(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.daemon_version) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_daemon_version() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.daemon_version_.Get(); +} +inline void XtcpConfig::_internal_set_daemon_version(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.daemon_version_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_daemon_version() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.daemon_version_.Mutable( GetArena()); } -inline void XtcpConfig::set_allocated_s3_flush_interval(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_daemon_version() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_flush_interval_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.daemon_version) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000020U)) { + return nullptr; } - + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + auto* released = _impl_.daemon_version_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.daemon_version_.Set("", GetArena()); + } + return released; +} +inline void XtcpConfig::set_allocated_daemon_version(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[1], 0x00000100U); + SetHasBit(_impl_._has_bits_[1], 0x00000020U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + ClearHasBit(_impl_._has_bits_[1], 0x00000020U); } - - _impl_.s3_flush_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_flush_interval) + _impl_.daemon_version_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.daemon_version_.IsDefault()) { + _impl_.daemon_version_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.daemon_version) } -// uint32 s3_flush_jitter_pct = 223 [json_name = "s3FlushJitterPct", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_flush_jitter_pct() { +// uint32 ipv4_ttl = 150 [json_name = "ipv4Ttl", (.buf.validate.field) = { +inline void XtcpConfig::clear_ipv4_ttl() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_flush_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x20000000U); + _impl_.ipv4_ttl_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x04000000U); } -inline ::uint32_t XtcpConfig::s3_flush_jitter_pct() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) - return _internal_s3_flush_jitter_pct(); +inline ::uint32_t XtcpConfig::ipv4_ttl() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv4_ttl) + return _internal_ipv4_ttl(); } -inline void XtcpConfig::set_s3_flush_jitter_pct(::uint32_t value) { - _internal_set_s3_flush_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x20000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_jitter_pct) +inline void XtcpConfig::set_ipv4_ttl(::uint32_t value) { + _internal_set_ipv4_ttl(value); + SetHasBit(_impl_._has_bits_[1], 0x04000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv4_ttl) } -inline ::uint32_t XtcpConfig::_internal_s3_flush_jitter_pct() const { +inline ::uint32_t XtcpConfig::_internal_ipv4_ttl() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_flush_jitter_pct_; + return _impl_.ipv4_ttl_; } -inline void XtcpConfig::_internal_set_s3_flush_jitter_pct(::uint32_t value) { +inline void XtcpConfig::_internal_set_ipv4_ttl(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_flush_jitter_pct_ = value; + _impl_.ipv4_ttl_ = value; } -// uint32 s3_flush_threshold_jitter_pct = 224 [json_name = "s3FlushThresholdJitterPct", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_flush_threshold_jitter_pct() { +// uint32 ipv6_hop_limit = 151 [json_name = "ipv6HopLimit", (.buf.validate.field) = { +inline void XtcpConfig::clear_ipv6_hop_limit() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_flush_threshold_jitter_pct_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); + _impl_.ipv6_hop_limit_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x08000000U); } -inline ::uint32_t XtcpConfig::s3_flush_threshold_jitter_pct() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) - return _internal_s3_flush_threshold_jitter_pct(); +inline ::uint32_t XtcpConfig::ipv6_hop_limit() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) + return _internal_ipv6_hop_limit(); } -inline void XtcpConfig::set_s3_flush_threshold_jitter_pct(::uint32_t value) { - _internal_set_s3_flush_threshold_jitter_pct(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_flush_threshold_jitter_pct) +inline void XtcpConfig::set_ipv6_hop_limit(::uint32_t value) { + _internal_set_ipv6_hop_limit(value); + SetHasBit(_impl_._has_bits_[1], 0x08000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.ipv6_hop_limit) } -inline ::uint32_t XtcpConfig::_internal_s3_flush_threshold_jitter_pct() const { +inline ::uint32_t XtcpConfig::_internal_ipv6_hop_limit() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_flush_threshold_jitter_pct_; + return _impl_.ipv6_hop_limit_; } -inline void XtcpConfig::_internal_set_s3_flush_threshold_jitter_pct(::uint32_t value) { +inline void XtcpConfig::_internal_set_ipv6_hop_limit(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_flush_threshold_jitter_pct_ = value; + _impl_.ipv6_hop_limit_ = value; } -// uint32 s3_upload_max_attempts = 225 [json_name = "s3UploadMaxAttempts", (.buf.validate.field) = { -inline void XtcpConfig::clear_s3_upload_max_attempts() { +// uint32 grpc_port = 160 [json_name = "grpcPort", (.buf.validate.field) = { +inline void XtcpConfig::clear_grpc_port() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_upload_max_attempts_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + _impl_.grpc_port_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x10000000U); } -inline ::uint32_t XtcpConfig::s3_upload_max_attempts() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) - return _internal_s3_upload_max_attempts(); +inline ::uint32_t XtcpConfig::grpc_port() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.grpc_port) + return _internal_grpc_port(); } -inline void XtcpConfig::set_s3_upload_max_attempts(::uint32_t value) { - _internal_set_s3_upload_max_attempts(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.s3_upload_max_attempts) +inline void XtcpConfig::set_grpc_port(::uint32_t value) { + _internal_set_grpc_port(value); + SetHasBit(_impl_._has_bits_[1], 0x10000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.grpc_port) } -inline ::uint32_t XtcpConfig::_internal_s3_upload_max_attempts() const { +inline ::uint32_t XtcpConfig::_internal_grpc_port() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.s3_upload_max_attempts_; + return _impl_.grpc_port_; } -inline void XtcpConfig::_internal_set_s3_upload_max_attempts(::uint32_t value) { +inline void XtcpConfig::_internal_set_grpc_port(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.s3_upload_max_attempts_ = value; + _impl_.grpc_port_ = value; } -// .google.protobuf.Duration s3_upload_backoff_cap = 226 [json_name = "s3UploadBackoffCap", (.buf.validate.field) = { -inline bool XtcpConfig::has_s3_upload_backoff_cap() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U); - PROTOBUF_ASSUME(!value || _impl_.s3_upload_backoff_cap_ != nullptr); - return value; +// string pyroscope_url = 170 [json_name = "pyroscopeUrl", (.buf.validate.field) = { +inline void XtcpConfig::clear_pyroscope_url() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pyroscope_url_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } -inline const ::google::protobuf::Duration& XtcpConfig::_internal_s3_upload_backoff_cap() const { +inline const ::std::string& XtcpConfig::pyroscope_url() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_url) + return _internal_pyroscope_url(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_pyroscope_url(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000040U); + _impl_.pyroscope_url_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_url) +} +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_pyroscope_url() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000040U); + ::std::string* _s = _internal_mutable_pyroscope_url(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.pyroscope_url) + return _s; +} +inline const ::std::string& XtcpConfig::_internal_pyroscope_url() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::google::protobuf::Duration* p = _impl_.s3_upload_backoff_cap_; - return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); + return _impl_.pyroscope_url_.Get(); } -inline const ::google::protobuf::Duration& XtcpConfig::s3_upload_backoff_cap() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) - return _internal_s3_upload_backoff_cap(); +inline void XtcpConfig::_internal_set_pyroscope_url(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pyroscope_url_.Set(value, GetArena()); } -inline void XtcpConfig::unsafe_arena_set_allocated_s3_upload_backoff_cap( - ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_pyroscope_url() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_upload_backoff_cap_); + return _impl_.pyroscope_url_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_pyroscope_url() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.pyroscope_url) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000040U)) { + return nullptr; } - _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + auto* released = _impl_.pyroscope_url_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.pyroscope_url_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) + return released; } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_s3_upload_backoff_cap() { +inline void XtcpConfig::set_allocated_pyroscope_url(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); - ::google::protobuf::Duration* released = _impl_.s3_upload_backoff_cap_; - _impl_.s3_upload_backoff_cap_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000040U); } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } - return released; + _impl_.pyroscope_url_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pyroscope_url_.IsDefault()) { + _impl_.pyroscope_url_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.pyroscope_url) } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_s3_upload_backoff_cap() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); - ::google::protobuf::Duration* temp = _impl_.s3_upload_backoff_cap_; - _impl_.s3_upload_backoff_cap_ = nullptr; - return temp; -} -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_s3_upload_backoff_cap() { +// string pyroscope_app_name = 171 [json_name = "pyroscopeAppName", (.buf.validate.field) = { +inline void XtcpConfig::clear_pyroscope_app_name() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.s3_upload_backoff_cap_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); - _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(p); - } - return _impl_.s3_upload_backoff_cap_; + _impl_.pyroscope_app_name_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_s3_upload_backoff_cap() +inline const ::std::string& XtcpConfig::pyroscope_app_name() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); - ::google::protobuf::Duration* _msg = _internal_mutable_s3_upload_backoff_cap(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) - return _msg; + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + return _internal_pyroscope_app_name(); } -inline void XtcpConfig::set_allocated_s3_upload_backoff_cap(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +template +PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_pyroscope_app_name(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.s3_upload_backoff_cap_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[1], 0x00000200U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); - } - - _impl_.s3_upload_backoff_cap_ = reinterpret_cast<::google::protobuf::Duration*>(value); - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap) + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + _impl_.pyroscope_app_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_app_name) } - -// .google.protobuf.Duration reconcile_frequency = 227 [json_name = "reconcileFrequency", (.buf.validate.field) = { -inline bool XtcpConfig::has_reconcile_frequency() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U); - PROTOBUF_ASSUME(!value || _impl_.reconcile_frequency_ != nullptr); - return value; +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_pyroscope_app_name() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + ::std::string* _s = _internal_mutable_pyroscope_app_name(); + // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + return _s; } -inline const ::google::protobuf::Duration& XtcpConfig::_internal_reconcile_frequency() const { +inline const ::std::string& XtcpConfig::_internal_pyroscope_app_name() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::google::protobuf::Duration* p = _impl_.reconcile_frequency_; - return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Duration>(&::google::protobuf::Duration_globals_); + return _impl_.pyroscope_app_name_.Get(); } -inline const ::google::protobuf::Duration& XtcpConfig::reconcile_frequency() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_frequency) - return _internal_reconcile_frequency(); +inline void XtcpConfig::_internal_set_pyroscope_app_name(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pyroscope_app_name_.Set(value, GetArena()); } -inline void XtcpConfig::unsafe_arena_set_allocated_reconcile_frequency( - ::google::protobuf::Duration* PROTOBUF_NULLABLE value) { +inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_pyroscope_app_name() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reconcile_frequency_); + return _impl_.pyroscope_app_name_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_pyroscope_app_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.pyroscope_app_name) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) { + return nullptr; } - _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000400U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); + auto* released = _impl_.pyroscope_app_name_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.pyroscope_app_name_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.reconcile_frequency) + return released; } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_reconcile_frequency() { +inline void XtcpConfig::set_allocated_pyroscope_app_name(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); - ::google::protobuf::Duration* released = _impl_.reconcile_frequency_; - _impl_.reconcile_frequency_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000010U); } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } + ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } - return released; + _impl_.pyroscope_app_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pyroscope_app_name_.IsDefault()) { + _impl_.pyroscope_app_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.pyroscope_app_name) } -inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_release_reconcile_frequency() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.reconcile_frequency) - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); - ::google::protobuf::Duration* temp = _impl_.reconcile_frequency_; - _impl_.reconcile_frequency_ = nullptr; - return temp; -} -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_reconcile_frequency() { +// uint32 pyroscope_sample_hz = 172 [json_name = "pyroscopeSampleHz", (.buf.validate.field) = { +inline void XtcpConfig::clear_pyroscope_sample_hz() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.reconcile_frequency_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena()); - _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(p); - } - return _impl_.reconcile_frequency_; + _impl_.pyroscope_sample_hz_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x20000000U); } -inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_reconcile_frequency() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000400U); - ::google::protobuf::Duration* _msg = _internal_mutable_reconcile_frequency(); - // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.reconcile_frequency) - return _msg; +inline ::uint32_t XtcpConfig::pyroscope_sample_hz() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) + return _internal_pyroscope_sample_hz(); } -inline void XtcpConfig::set_allocated_reconcile_frequency(::google::protobuf::Duration* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline void XtcpConfig::set_pyroscope_sample_hz(::uint32_t value) { + _internal_set_pyroscope_sample_hz(value); + SetHasBit(_impl_._has_bits_[1], 0x20000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_sample_hz) +} +inline ::uint32_t XtcpConfig::_internal_pyroscope_sample_hz() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pyroscope_sample_hz_; +} +inline void XtcpConfig::_internal_set_pyroscope_sample_hz(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reconcile_frequency_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[1], 0x00000400U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); - } + _impl_.pyroscope_sample_hz_ = value; +} - _impl_.reconcile_frequency_ = reinterpret_cast<::google::protobuf::Duration*>(value); - // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.reconcile_frequency) +// uint32 pyroscope_upload_interval_sec = 173 [json_name = "pyroscopeUploadIntervalSec", (.buf.validate.field) = { +inline void XtcpConfig::clear_pyroscope_upload_interval_sec() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pyroscope_upload_interval_sec_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); +} +inline ::uint32_t XtcpConfig::pyroscope_upload_interval_sec() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) + return _internal_pyroscope_upload_interval_sec(); +} +inline void XtcpConfig::set_pyroscope_upload_interval_sec(::uint32_t value) { + _internal_set_pyroscope_upload_interval_sec(value); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.pyroscope_upload_interval_sec) +} +inline ::uint32_t XtcpConfig::_internal_pyroscope_upload_interval_sec() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pyroscope_upload_interval_sec_; +} +inline void XtcpConfig::_internal_set_pyroscope_upload_interval_sec(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pyroscope_upload_interval_sec_ = value; } -// bool reconcile_before_poll = 228 [json_name = "reconcileBeforePoll"]; -inline void XtcpConfig::clear_reconcile_before_poll() { +// bool resolve_container_id = 200 [json_name = "resolveContainerId", (.buf.validate.field) = { +inline void XtcpConfig::clear_resolve_container_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.reconcile_before_poll_ = false; - ClearHasBit(_impl_._has_bits_[1], 0x01000000U); + _impl_.resolve_container_id_ = false; + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } -inline bool XtcpConfig::reconcile_before_poll() const { - // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.reconcile_before_poll) - return _internal_reconcile_before_poll(); +inline bool XtcpConfig::resolve_container_id() const { + // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.resolve_container_id) + return _internal_resolve_container_id(); } -inline void XtcpConfig::set_reconcile_before_poll(bool value) { - _internal_set_reconcile_before_poll(value); - SetHasBit(_impl_._has_bits_[1], 0x01000000U); - // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.reconcile_before_poll) +inline void XtcpConfig::set_resolve_container_id(bool value) { + _internal_set_resolve_container_id(value); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); + // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.resolve_container_id) } -inline bool XtcpConfig::_internal_reconcile_before_poll() const { +inline bool XtcpConfig::_internal_resolve_container_id() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.reconcile_before_poll_; + return _impl_.resolve_container_id_; } -inline void XtcpConfig::_internal_set_reconcile_before_poll(bool value) { +inline void XtcpConfig::_internal_set_resolve_container_id(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.reconcile_before_poll_ = value; + _impl_.resolve_container_id_ = value; } -// bool enrich_container_enable = 230 [json_name = "enrichContainerEnable"]; +// bool enrich_container_enable = 201 [json_name = "enrichContainerEnable"]; inline void XtcpConfig::clear_enrich_container_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_container_enable_ = false; @@ -8422,11 +8422,11 @@ inline void XtcpConfig::_internal_set_enrich_container_enable(bool value) { _impl_.enrich_container_enable_ = value; } -// string docker_socket_path = 231 [json_name = "dockerSocketPath", (.buf.validate.field) = { +// string docker_socket_path = 202 [json_name = "dockerSocketPath", (.buf.validate.field) = { inline void XtcpConfig::clear_docker_socket_path() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.docker_socket_path_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000004U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } inline const ::std::string& XtcpConfig::docker_socket_path() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -8436,13 +8436,13 @@ inline const ::std::string& XtcpConfig::docker_socket_path() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_docker_socket_path(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000004U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); _impl_.docker_socket_path_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.docker_socket_path) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_docker_socket_path() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000004U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); ::std::string* _s = _internal_mutable_docker_socket_path(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.docker_socket_path) return _s; @@ -8462,10 +8462,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_docker_sock inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_docker_socket_path() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.docker_socket_path) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000004U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000080U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000004U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); auto* released = _impl_.docker_socket_path_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.docker_socket_path_.Set("", GetArena()); @@ -8475,9 +8475,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_docker_socket_path() inline void XtcpConfig::set_allocated_docker_socket_path(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000004U); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000004U); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } _impl_.docker_socket_path_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.docker_socket_path_.IsDefault()) { @@ -8486,7 +8486,7 @@ inline void XtcpConfig::set_allocated_docker_socket_path(::std::string* PROTOBUF // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.docker_socket_path) } -// bool enrich_lldp_enable = 232 [json_name = "enrichLldpEnable"]; +// bool enrich_lldp_enable = 210 [json_name = "enrichLldpEnable"]; inline void XtcpConfig::clear_enrich_lldp_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_lldp_enable_ = false; @@ -8510,11 +8510,11 @@ inline void XtcpConfig::_internal_set_enrich_lldp_enable(bool value) { _impl_.enrich_lldp_enable_ = value; } -// string lldpd_socket_path = 233 [json_name = "lldpdSocketPath", (.buf.validate.field) = { +// string lldpd_socket_path = 211 [json_name = "lldpdSocketPath", (.buf.validate.field) = { inline void XtcpConfig::clear_lldpd_socket_path() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lldpd_socket_path_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000008U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); } inline const ::std::string& XtcpConfig::lldpd_socket_path() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -8524,13 +8524,13 @@ inline const ::std::string& XtcpConfig::lldpd_socket_path() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_lldpd_socket_path(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000008U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); _impl_.lldpd_socket_path_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.lldpd_socket_path) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_lldpd_socket_path() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000008U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); ::std::string* _s = _internal_mutable_lldpd_socket_path(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.lldpd_socket_path) return _s; @@ -8550,10 +8550,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_lldpd_socke inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_lldpd_socket_path() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.lldpd_socket_path) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000008U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000008U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); auto* released = _impl_.lldpd_socket_path_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.lldpd_socket_path_.Set("", GetArena()); @@ -8563,9 +8563,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_lldpd_socket_path() inline void XtcpConfig::set_allocated_lldpd_socket_path(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000008U); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000008U); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); } _impl_.lldpd_socket_path_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lldpd_socket_path_.IsDefault()) { @@ -8574,11 +8574,11 @@ inline void XtcpConfig::set_allocated_lldpd_socket_path(::std::string* PROTOBUF_ // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.lldpd_socket_path) } -// string lldpd_version_hint = 234 [json_name = "lldpdVersionHint", (.buf.validate.field) = { +// string lldpd_version_hint = 212 [json_name = "lldpdVersionHint", (.buf.validate.field) = { inline void XtcpConfig::clear_lldpd_version_hint() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.lldpd_version_hint_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000010U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } inline const ::std::string& XtcpConfig::lldpd_version_hint() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -8588,13 +8588,13 @@ inline const ::std::string& XtcpConfig::lldpd_version_hint() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_lldpd_version_hint(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000010U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); _impl_.lldpd_version_hint_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.lldpd_version_hint) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_lldpd_version_hint() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000010U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); ::std::string* _s = _internal_mutable_lldpd_version_hint(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.lldpd_version_hint) return _s; @@ -8614,10 +8614,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_lldpd_versi inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_lldpd_version_hint() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.lldpd_version_hint) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000010U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000200U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000010U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); auto* released = _impl_.lldpd_version_hint_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.lldpd_version_hint_.Set("", GetArena()); @@ -8627,9 +8627,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_lldpd_version_hint() inline void XtcpConfig::set_allocated_lldpd_version_hint(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000010U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000010U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } _impl_.lldpd_version_hint_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lldpd_version_hint_.IsDefault()) { @@ -8638,7 +8638,7 @@ inline void XtcpConfig::set_allocated_lldpd_version_hint(::std::string* PROTOBUF // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.lldpd_version_hint) } -// bool enrich_nic_enable = 235 [json_name = "enrichNicEnable"]; +// bool enrich_nic_enable = 220 [json_name = "enrichNicEnable"]; inline void XtcpConfig::clear_enrich_nic_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_nic_enable_ = false; @@ -8662,11 +8662,11 @@ inline void XtcpConfig::_internal_set_enrich_nic_enable(bool value) { _impl_.enrich_nic_enable_ = value; } -// uint32 uplink_count = 236 [json_name = "uplinkCount", (.buf.validate.field) = { +// uint32 uplink_count = 221 [json_name = "uplinkCount", (.buf.validate.field) = { inline void XtcpConfig::clear_uplink_count() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink_count_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000010U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline ::uint32_t XtcpConfig::uplink_count() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.uplink_count) @@ -8674,7 +8674,7 @@ inline ::uint32_t XtcpConfig::uplink_count() const { } inline void XtcpConfig::set_uplink_count(::uint32_t value) { _internal_set_uplink_count(value); - SetHasBit(_impl_._has_bits_[2], 0x00000010U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.uplink_count) } inline ::uint32_t XtcpConfig::_internal_uplink_count() const { @@ -8686,7 +8686,7 @@ inline void XtcpConfig::_internal_set_uplink_count(::uint32_t value) { _impl_.uplink_count_ = value; } -// repeated string uplink_interfaces = 237 [json_name = "uplinkInterfaces", (.buf.validate.field) = { +// repeated string uplink_interfaces = 222 [json_name = "uplinkInterfaces", (.buf.validate.field) = { inline int XtcpConfig::_internal_uplink_interfaces_size() const { return _internal_uplink_interfaces().size(); } @@ -8696,7 +8696,7 @@ inline int XtcpConfig::uplink_interfaces_size() const { inline void XtcpConfig::clear_uplink_interfaces() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink_interfaces_.Clear(); - ClearHasBit(_impl_._has_bits_[0], 0x00020000U); + ClearHasBit(_impl_._has_bits_[0], 0x00400000U); } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::add_uplink_interfaces() ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -8704,7 +8704,7 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::add_uplink_interfaces() ::std::string* _s = _internal_mutable_uplink_interfaces()->InternalAddWithArena( ::google::protobuf::MessageLite::internal_visibility(), GetArena()); - SetHasBit(_impl_._has_bits_[0], 0x00020000U); + SetHasBit(_impl_._has_bits_[0], 0x00400000U); // @@protoc_insertion_point(field_add_mutable:xtcp_config.v1.XtcpConfig.uplink_interfaces) return _s; } @@ -8732,7 +8732,7 @@ inline void XtcpConfig::add_uplink_interfaces(Arg_&& value, Args_... args) { ::google::protobuf::MessageLite::internal_visibility(), GetArena(), *_internal_mutable_uplink_interfaces(), ::std::forward(value), args... ); - SetHasBit(_impl_._has_bits_[0], 0x00020000U); + SetHasBit(_impl_._has_bits_[0], 0x00400000U); // @@protoc_insertion_point(field_add:xtcp_config.v1.XtcpConfig.uplink_interfaces) } inline const ::google::protobuf::RepeatedPtrField<::std::string>& XtcpConfig::uplink_interfaces() @@ -8742,7 +8742,7 @@ inline const ::google::protobuf::RepeatedPtrField<::std::string>& XtcpConfig::up } inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL XtcpConfig::mutable_uplink_interfaces() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00020000U); + SetHasBit(_impl_._has_bits_[0], 0x00400000U); // @@protoc_insertion_point(field_mutable_list:xtcp_config.v1.XtcpConfig.uplink_interfaces) ::google::protobuf::internal::TSanWrite(&_impl_); return _internal_mutable_uplink_interfaces(); @@ -8758,11 +8758,11 @@ XtcpConfig::_internal_mutable_uplink_interfaces() { return &_impl_.uplink_interfaces_; } -// bool populate_nsid = 238 [json_name = "populateNsid"]; +// bool populate_nsid = 230 [json_name = "populateNsid"]; inline void XtcpConfig::clear_populate_nsid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.populate_nsid_ = false; - ClearHasBit(_impl_._has_bits_[2], 0x00000008U); + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); } inline bool XtcpConfig::populate_nsid() const { // @@protoc_insertion_point(field_get:xtcp_config.v1.XtcpConfig.populate_nsid) @@ -8770,7 +8770,7 @@ inline bool XtcpConfig::populate_nsid() const { } inline void XtcpConfig::set_populate_nsid(bool value) { _internal_set_populate_nsid(value); - SetHasBit(_impl_._has_bits_[2], 0x00000008U); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.populate_nsid) } inline bool XtcpConfig::_internal_populate_nsid() const { @@ -8782,7 +8782,7 @@ inline void XtcpConfig::_internal_set_populate_nsid(bool value) { _impl_.populate_nsid_ = value; } -// bool enrich_asn_enable = 239 [json_name = "enrichAsnEnable"]; +// bool enrich_asn_enable = 240 [json_name = "enrichAsnEnable"]; inline void XtcpConfig::clear_enrich_asn_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_asn_enable_ = false; @@ -8806,11 +8806,11 @@ inline void XtcpConfig::_internal_set_enrich_asn_enable(bool value) { _impl_.enrich_asn_enable_ = value; } -// string asn_db_path = 240 [json_name = "asnDbPath", (.buf.validate.field) = { +// string asn_db_path = 241 [json_name = "asnDbPath", (.buf.validate.field) = { inline void XtcpConfig::clear_asn_db_path() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.asn_db_path_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } inline const ::std::string& XtcpConfig::asn_db_path() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -8820,13 +8820,13 @@ inline const ::std::string& XtcpConfig::asn_db_path() const template PROTOBUF_ALWAYS_INLINE void XtcpConfig::set_asn_db_path(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); _impl_.asn_db_path_.Set(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_config.v1.XtcpConfig.asn_db_path) } inline ::std::string* PROTOBUF_NONNULL XtcpConfig::mutable_asn_db_path() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); ::std::string* _s = _internal_mutable_asn_db_path(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.asn_db_path) return _s; @@ -8846,10 +8846,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpConfig::_internal_mutable_asn_db_path inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_asn_db_path() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.asn_db_path) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000020U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000400U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); auto* released = _impl_.asn_db_path_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.asn_db_path_.Set("", GetArena()); @@ -8859,9 +8859,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpConfig::release_asn_db_path() { inline void XtcpConfig::set_allocated_asn_db_path(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000020U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000020U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } _impl_.asn_db_path_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.asn_db_path_.IsDefault()) { @@ -8870,9 +8870,9 @@ inline void XtcpConfig::set_allocated_asn_db_path(::std::string* PROTOBUF_NULLAB // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.asn_db_path) } -// .google.protobuf.Duration asn_refresh_interval = 241 [json_name = "asnRefreshInterval"]; +// .google.protobuf.Duration asn_refresh_interval = 242 [json_name = "asnRefreshInterval"]; inline bool XtcpConfig::has_asn_refresh_interval() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00008000U); PROTOBUF_ASSUME(!value || _impl_.asn_refresh_interval_ != nullptr); return value; } @@ -8893,16 +8893,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_asn_refresh_interval( } _impl_.asn_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.asn_refresh_interval) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_asn_refresh_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); ::google::protobuf::Duration* released = _impl_.asn_refresh_interval_; _impl_.asn_refresh_interval_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -8922,7 +8922,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.asn_refresh_interval) - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); ::google::protobuf::Duration* temp = _impl_.asn_refresh_interval_; _impl_.asn_refresh_interval_ = nullptr; return temp; @@ -8937,7 +8937,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_asn_refresh_interval() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); ::google::protobuf::Duration* _msg = _internal_mutable_asn_refresh_interval(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.asn_refresh_interval) return _msg; @@ -8954,16 +8954,16 @@ inline void XtcpConfig::set_allocated_asn_refresh_interval(::google::protobuf::D if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } _impl_.asn_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); // @@protoc_insertion_point(field_set_allocated:xtcp_config.v1.XtcpConfig.asn_refresh_interval) } -// bool enrich_locality_enable = 242 [json_name = "enrichLocalityEnable"]; +// bool enrich_locality_enable = 245 [json_name = "enrichLocalityEnable"]; inline void XtcpConfig::clear_enrich_locality_enable() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.enrich_locality_enable_ = false; @@ -8987,9 +8987,9 @@ inline void XtcpConfig::_internal_set_enrich_locality_enable(bool value) { _impl_.enrich_locality_enable_ = value; } -// .google.protobuf.Duration locality_refresh_interval = 243 [json_name = "localityRefreshInterval"]; +// .google.protobuf.Duration locality_refresh_interval = 246 [json_name = "localityRefreshInterval"]; inline bool XtcpConfig::has_locality_refresh_interval() const { - bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U); + bool value = CheckHasBit(_impl_._has_bits_[1], 0x00010000U); PROTOBUF_ASSUME(!value || _impl_.locality_refresh_interval_ != nullptr); return value; } @@ -9010,16 +9010,16 @@ inline void XtcpConfig::unsafe_arena_set_allocated_locality_refresh_interval( } _impl_.locality_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xtcp_config.v1.XtcpConfig.locality_refresh_interval) } inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::release_locality_refresh_interval() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); ::google::protobuf::Duration* released = _impl_.locality_refresh_interval_; _impl_.locality_refresh_interval_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -9039,7 +9039,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NULLABLE XtcpConfig::unsafe_arena_ ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_config.v1.XtcpConfig.locality_refresh_interval) - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); ::google::protobuf::Duration* temp = _impl_.locality_refresh_interval_; _impl_.locality_refresh_interval_ = nullptr; return temp; @@ -9054,7 +9054,7 @@ inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::_internal_muta } inline ::google::protobuf::Duration* PROTOBUF_NONNULL XtcpConfig::mutable_locality_refresh_interval() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); ::google::protobuf::Duration* _msg = _internal_mutable_locality_refresh_interval(); // @@protoc_insertion_point(field_mutable:xtcp_config.v1.XtcpConfig.locality_refresh_interval) return _msg; @@ -9071,9 +9071,9 @@ inline void XtcpConfig::set_allocated_locality_refresh_interval(::google::protob if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } _impl_.locality_refresh_interval_ = reinterpret_cast<::google::protobuf::Duration*>(value); diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.grpc.pb.h b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.grpc.pb.h index 3673ea4..9ff7172 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.grpc.pb.h +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.grpc.pb.h @@ -5,20 +5,52 @@ // // xTCP - eXport TCP Inet Diagnostic messages // -// These are all the structs relating to the TCP diagnotic module in the kernel +// XtcpFlatRecord is one flat row per socket: daemon metadata, daemon-computed +// enrichment, and the raw kernel inet_diag payload (struct inet_diag_msg + every +// INET_DIAG_* extension xtcp requests). Protobuf's smallest scalar is 32 bits, +// so kernel __u8/__u16 members are widened to uint32; the trailing comment on +// every payload field records the kernel member and its C type. // -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 +// Kernel source of truth (Linux 7.2-rc, include/uapi/linux/): +// inet_diag.h struct inet_diag_msg, inet_diag_sockid, inet_diag_meminfo, +// tcpvegas_info, tcp_dctcp_info, tcp_bbr_info, inet_diag_sockopt, +// enum INET_DIAG_* (extension attribute ids) +// tcp.h struct tcp_info +// sock_diag.h enum SK_MEMINFO_* +// net/ipv4/inet_diag.c inet_sk_diag_fill / inet_diag_msg_attrs_fill (what +// each nla_put_* actually carries) // -// There are links to the kernel source showing where the struct came from. +// --------------------------------------------------------------------------- +// FIELD-NUMBER ALLOCATION POLICY (v2, 2026-09) +// --------------------------------------------------------------------------- +// 1-299 metadata daemon identity, time, namespace, container, labels, +// bookkeeping, per-uplink host topology (one block each) +// 300-399 enrichment daemon-COMPUTED fields (NOT read from the kernel): +// 300-309 socket-side, 310-349 destination-side, +// 350-389 source-side (future), 390-399 spare +// 400-999 spare unallocated; open a new metadata/enrichment block here +// 1000+ payload raw kernel inet_diag data, ONE hundred-block per kernel +// struct / INET_DIAG_* extension (1000 inet_diag_msg, +// 1100 meminfo, 1200 tcp_info, 1300 cong, 1400 tos/tclass, +// 1500 skmeminfo, 1600 shutdown, 1700 vegas, 1800 dctcp, +// 1900 bbr, 2000 class_id/sockopt/cgroup_id; next free +// block = 2100) +// Wire cost: tags 1-15 = 1 byte, 16-2047 = 2 bytes, 2048+ = 3 bytes. Every field +// here is <= 2047. Fill free slots inside an existing block before opening one +// above 2047. +// Naming: payload fields are _ using the kernel's +// exact spelling (tcp_info_rttvar, not rtt_var). Attributes with no struct take +// the lowercased INET_DIAG_* name (inet_diag_tos). The six inet_diag_msg_socket_* +// sockid fields keep their descriptive names (heavily used downstream). +// Evolution: never reuse a number or a name (add both to `reserved`); any rename +// or renumber is a new record epoch -> bump XtcpFlatRecordSchemaVersion +// (pkg/xtcp/schema_version.go) and add the matching ClickHouse _vN table + MV +// (build/containers/clickhouse/initdb.d/sql/). Adding a field in a free slot is +// NOT an epoch bump. ClickHouse maps columns by field NAME; Parquet by NAME; +// the csv/tsv marshallers by DECLARATION ORDER; gRPC clients are built from +// gen/go in this repo. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder -// -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto -// // https://protobuf.dev/programming-guides/encoding/#structure // #ifndef GRPC_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto__INCLUDED diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc index b890493..3d1a2b5 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.cc @@ -58,11 +58,11 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl { PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_._has_bits_), 0, // no _extensions_ - 2103, 248, // max_field_number, fast_idx_mask + 2003, 248, // max_field_number, fast_idx_mask offsetof(ParseTableT_, field_lookup_table), 535297532, // skipmap offsetof(ParseTableT_, field_entries), - 158, // num_field_entries + 161, // num_field_entries 0, // num_aux_entries offsetof(ParseTableT_, field_names), // no aux_entries class_data, @@ -101,10 +101,10 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl {::_pbi::TcParser::FastV32S2, {640, 13, 0, PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.nsid_)}}, - // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; - {::_pbi::TcParser::FastV32S2, - {16264, 18, 0, - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_)}}, + // uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; + {::_pbi::TcParser::FastV64S2, + {5256, 17, 0, + PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_next_hop_asn_)}}, // string label = 50 [json_name = "label"]; {::_pbi::TcParser::FastUS2, {914, 8, 0, @@ -127,7 +127,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_model_)}}, // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; {::_pbi::TcParser::FastV32S2, - {1720, 17, 0, + {1720, 18, 0, PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_vendor_)}}, // string container_id = 40 [json_name = "containerId"]; {::_pbi::TcParser::FastUS2, @@ -162,7 +162,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl {504, 14, 0, PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netns_inode_)}}, }}, {{ - 40, 0, 12, + 40, 0, 18, 62448, 8, 65423, 14, 65535, 17, @@ -175,38 +175,42 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl 65535, 30, 65280, 30, 65039, 38, + 65535, 43, + 65535, 43, + 65535, 43, + 65535, 43, + 16367, 43, + 63742, 46, 1001, 0, 7, - 0, 43, - 65528, 59, - 65535, 62, - 65535, 62, - 65535, 62, - 65535, 62, - 65295, 62, + 3072, 50, + 65534, 64, + 65535, 65, + 65535, 65, + 65535, 65, + 65535, 65, + 65295, 65, 1201, 0, 7, - 15360, 66, - 0, 78, - 0, 94, - 0, 110, - 65534, 126, - 65535, 127, - 65511, 127, + 15360, 69, + 0, 81, + 0, 97, + 0, 113, + 65534, 129, + 65535, 130, + 65511, 130, 1401, 0, 1, - 65532, 129, + 65532, 132, 1501, 0, 1, - 65024, 131, + 65024, 134, 1600, 0, 1, - 65534, 140, + 65534, 143, 1701, 0, 1, - 65520, 141, + 65520, 144, 1801, 0, 1, - 65504, 145, + 65504, 148, 1901, 0, 1, - 65504, 150, + 65504, 153, 2001, 0, 1, - 65532, 155, - 2103, 0, 1, - 65534, 157, + 65528, 158, 65535, 65535 }}, {{ // uint32 schema_version = 1 [json_name = "schemaVersion"]; @@ -242,7 +246,7 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // uint64 socket_fd = 61 [json_name = "socketFd"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.socket_fd_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // string uplink1_ifname = 100 [json_name = "uplink1Ifname"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_ifname_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink1_nic_driver = 101 [json_name = "uplink1NicDriver"]; @@ -250,13 +254,13 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // string uplink1_nic_model = 102 [json_name = "uplink1NicModel"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_model_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_vendor_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_vendor_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_device_), _Internal::kHasBitsOffset + 43, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_device_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink1_nic_bus_info = 105 [json_name = "uplink1NicBusInfo"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_bus_info_), _Internal::kHasBitsOffset + 21, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_speed_mbps_), _Internal::kHasBitsOffset + 44, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_speed_mbps_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink1_nic_fw_version = 107 [json_name = "uplink1NicFwVersion"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_fw_version_), _Internal::kHasBitsOffset + 22, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink1_lldp_chassis_name = 120 [json_name = "uplink1LldpChassisName"]; @@ -276,13 +280,13 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl // string uplink2_nic_model = 202 [json_name = "uplink2NicModel"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_model_), _Internal::kHasBitsOffset + 30, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_vendor_), _Internal::kHasBitsOffset + 45, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_vendor_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_device_), _Internal::kHasBitsOffset + 46, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_pci_device_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink2_nic_bus_info = 205 [json_name = "uplink2NicBusInfo"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_bus_info_), _Internal::kHasBitsOffset + 31, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_speed_mbps_), _Internal::kHasBitsOffset + 47, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_speed_mbps_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // string uplink2_nic_fw_version = 207 [json_name = "uplink2NicFwVersion"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_nic_fw_version_), _Internal::kHasBitsOffset + 32, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink2_lldp_chassis_name = 220 [json_name = "uplink2LldpChassisName"]; @@ -295,240 +299,246 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_lldp_port_id_), _Internal::kHasBitsOffset + 36, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // string uplink2_lldp_port_descr = 224 [json_name = "uplink2LldpPortDescr"]; {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink2_lldp_port_descr_), _Internal::kHasBitsOffset + 37, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string enrich_socket_interface_name = 300 [json_name = "enrichSocketInterfaceName"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_interface_name_), _Internal::kHasBitsOffset + 38, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality enrich_socket_dest_locality = 310 [json_name = "enrichSocketDestLocality"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_locality_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // uint32 enrich_socket_dest_egress_ifindex = 311 [json_name = "enrichSocketDestEgressIfindex"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_egress_ifindex_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string enrich_socket_dest_egress_ifname = 312 [json_name = "enrichSocketDestEgressIfname"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_egress_ifname_), _Internal::kHasBitsOffset + 39, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint64 enrich_socket_dest_asn = 320 [json_name = "enrichSocketDestAsn"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_asn_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_next_hop_asn_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + // string enrich_socket_dest_network_owner = 322 [json_name = "enrichSocketDestNetworkOwner"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.enrich_socket_dest_network_owner_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_family_), _Internal::kHasBitsOffset + 48, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_family_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_state_), _Internal::kHasBitsOffset + 49, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_state_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_timer_), _Internal::kHasBitsOffset + 50, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_timer_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_retrans_), _Internal::kHasBitsOffset + 51, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_retrans_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_port_), _Internal::kHasBitsOffset + 52, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_port_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_port_), _Internal::kHasBitsOffset + 53, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_port_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_), _Internal::kHasBitsOffset + 38, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_source_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, // bytes inet_diag_msg_socket_destination = 1008 [json_name = "inetDiagMsgSocketDestination"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_), _Internal::kHasBitsOffset + 39, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_), _Internal::kHasBitsOffset + 42, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)}, // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_cookie_), _Internal::kHasBitsOffset + 55, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_asn_), _Internal::kHasBitsOffset + 56, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, - // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_next_hop_asn_), _Internal::kHasBitsOffset + 57, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_cookie_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_expires_), _Internal::kHasBitsOffset + 54, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_expires_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_rqueue_), _Internal::kHasBitsOffset + 58, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_rqueue_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), _Internal::kHasBitsOffset + 59, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_uid_), _Internal::kHasBitsOffset + 60, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_uid_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_inode_), _Internal::kHasBitsOffset + 61, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), _Internal::kHasBitsOffset + 40, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_locality_), _Internal::kHasBitsOffset + 62, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_inode_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 63, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_rmem_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 64, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_wmem_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 65, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_fmem_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 66, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.mem_info_tmem_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 67, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_state_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 68, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ca_state_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 69, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retransmits_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 70, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_probes_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 71, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_backoff_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 72, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_send_scale_), _Internal::kHasBitsOffset + 73, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), _Internal::kHasBitsOffset + 74, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_options_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_snd_wscale = 1207 [json_name = "tcpInfoSndWscale"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wscale_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_rcv_wscale = 1208 [json_name = "tcpInfoRcvWscale"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wscale_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 75, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), _Internal::kHasBitsOffset + 76, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_fastopen_client_fail = 1210 [json_name = "tcpInfoFastopenClientFail"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fastopen_client_fail_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 77, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rto_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 78, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_ato_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 79, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_mss_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 80, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_mss_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 81, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_unacked_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 82, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sacked_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 83, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_lost_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 84, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_retrans_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 85, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_fackets_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 86, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_sent_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 87, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_sent_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 88, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_data_recv_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 89, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_last_ack_recv_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 90, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pmtu_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 91, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 92, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_var_), _Internal::kHasBitsOffset + 93, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rtt_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_rttvar = 1231 [json_name = "tcpInfoRttvar"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rttvar_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 94, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 95, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_adv_mss_), _Internal::kHasBitsOffset + 96, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_advmss = 1234 [json_name = "tcpInfoAdvmss"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_advmss_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 97, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reordering_), _Internal::kHasBitsOffset + 100, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 98, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), _Internal::kHasBitsOffset + 101, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 99, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_space_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 102, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_retrans_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pacing_rate_), _Internal::kHasBitsOffset + 100, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_pacing_rate_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_max_pacing_rate_), _Internal::kHasBitsOffset + 101, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_max_pacing_rate_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 104, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_acked_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 105, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_received_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 103, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_out_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 106, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), _Internal::kHasBitsOffset + 107, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_segs_in_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 tcp_info_notsent_bytes = 1245 [json_name = "tcpInfoNotsentBytes"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_notsent_bytes_), _Internal::kHasBitsOffset + 110, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 108, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_min_rtt_), _Internal::kHasBitsOffset + 111, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 109, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 112, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_), _Internal::kHasBitsOffset + 110, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivery_rate_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_busy_time_), _Internal::kHasBitsOffset + 111, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_busy_time_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 114, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rwnd_limited_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 115, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_sndbuf_limited_), _Internal::kHasBitsOffset + 118, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 113, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_), _Internal::kHasBitsOffset + 116, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 117, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_delivered_ce_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_sent_), _Internal::kHasBitsOffset + 116, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_sent_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 119, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_bytes_retrans_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_dsack_dups_), _Internal::kHasBitsOffset + 118, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_dsack_dups_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 120, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_reord_seen_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 121, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_ooopack_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 122, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_snd_wnd_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 123, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rcv_wnd_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 124, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_rehash_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 125, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 126, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 127, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_string_), _Internal::kHasBitsOffset + 41, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.congestion_algorithm_enum_), _Internal::kHasBitsOffset + 128, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, - // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.type_of_service_), _Internal::kHasBitsOffset + 129, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.traffic_class_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), _Internal::kHasBitsOffset + 130, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // string inet_diag_cong = 1300 [json_name = "inetDiagCong"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_cong_), _Internal::kHasBitsOffset + 43, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm inet_diag_cong_enum = 1301 [json_name = "inetDiagCongEnum"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_cong_enum_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // uint32 inet_diag_tos = 1401 [json_name = "inetDiagTos"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_tos_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 inet_diag_tclass = 1402 [json_name = "inetDiagTclass"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_tclass_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 131, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), _Internal::kHasBitsOffset + 132, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 sk_mem_info_rcvbuf = 1502 [json_name = "skMemInfoRcvbuf"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_rcvbuf_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 133, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), _Internal::kHasBitsOffset + 134, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 sk_mem_info_sndbuf = 1504 [json_name = "skMemInfoSndbuf"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_sndbuf_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 135, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 136, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 137, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_optmem_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 138, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_backlog_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 139, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.shutdown_state_), _Internal::kHasBitsOffset + 140, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sk_mem_info_drops_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 inet_diag_shutdown = 1600 [json_name = "inetDiagShutdown"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_shutdown_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 141, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), _Internal::kHasBitsOffset + 142, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_enabled_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 vegas_info_rttcnt = 1702 [json_name = "vegasInfoRttcnt"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rttcnt_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 143, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_min_rtt_), _Internal::kHasBitsOffset + 144, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_rtt_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 vegas_info_minrtt = 1704 [json_name = "vegasInfoMinrtt"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.vegas_info_minrtt_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 145, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_enabled_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 146, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ce_state_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 147, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_alpha_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 148, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_ecn_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 149, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.dctcp_info_ab_tot_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 150, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_lo_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 151, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_bw_hi_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 152, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_min_rtt_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 153, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), _Internal::kHasBitsOffset + 156, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 154, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 class_id = 2001 [json_name = "classId"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.class_id_), _Internal::kHasBitsOffset + 155, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_), _Internal::kHasBitsOffset + 157, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, - // uint64 c_group = 2103 [json_name = "cGroup"]; - {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.c_group_), _Internal::kHasBitsOffset + 156, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), _Internal::kHasBitsOffset + 157, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 inet_diag_class_id = 2001 [json_name = "inetDiagClassId"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_class_id_), _Internal::kHasBitsOffset + 158, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint32 inet_diag_sockopt = 2002 [json_name = "inetDiagSockopt"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_sockopt_), _Internal::kHasBitsOffset + 160, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)}, + // uint64 inet_diag_cgroup_id = 2003 [json_name = "inetDiagCgroupId"]; + {PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_cgroup_id_), _Internal::kHasBitsOffset + 159, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)}, }}, // no aux_entries {{ - "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\47\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\33\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "\42\0\16\0\10\10\5\0\0\14\21\16\17\5\3\0\0\0\16\22\21\0\0\24\0\26\31\27\24\24\27\16\22\21\0\0\24\0\26\31\27\24\24\27\34\0\0\40\0\0\40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "xtcp_flat_record.v1.XtcpFlatRecord" "daemon_version" "hostname" @@ -560,8 +570,10 @@ constexpr XtcpFlatRecord::ParseTableT_ XtcpFlatRecord::InternalGenerateParseTabl "uplink2_lldp_mgmt_ip" "uplink2_lldp_port_id" "uplink2_lldp_port_descr" - "inet_diag_msg_socket_dest_network_owner" - "congestion_algorithm_string" + "enrich_socket_interface_name" + "enrich_socket_dest_egress_ifname" + "enrich_socket_dest_network_owner" + "inet_diag_cong" }}, }; } @@ -610,8 +622,8 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( netns_inode_{::uint64_t{0u}}, record_counter_{::uint64_t{0u}}, socket_fd_{::uint64_t{0u}}, + enrich_socket_dest_next_hop_asn_{::uint64_t{0u}}, uplink1_nic_pci_vendor_{0u}, - inet_diag_msg_socket_interface_{0u}, uplink1_ifname_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), @@ -669,16 +681,22 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( uplink2_lldp_port_descr_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - inet_diag_msg_socket_source_( + enrich_socket_interface_name_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - inet_diag_msg_socket_destination_( + enrich_socket_dest_egress_ifname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + enrich_socket_dest_network_owner_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - inet_diag_msg_socket_dest_network_owner_( + inet_diag_msg_socket_source_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + inet_diag_msg_socket_destination_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - congestion_algorithm_string_( + inet_diag_cong_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), netlinker_id_{::uint64_t{0u}}, @@ -687,21 +705,22 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( uplink2_nic_pci_vendor_{0u}, uplink2_nic_pci_device_{0u}, uplink2_nic_speed_mbps_{0u}, + enrich_socket_dest_locality_{static_cast< ::xtcp_flat_record::v1::XtcpFlatRecord_Locality >(0)}, + enrich_socket_dest_asn_{::uint64_t{0u}}, + enrich_socket_dest_egress_ifindex_{0u}, inet_diag_msg_family_{0u}, inet_diag_msg_state_{0u}, inet_diag_msg_timer_{0u}, inet_diag_msg_retrans_{0u}, inet_diag_msg_socket_source_port_{0u}, inet_diag_msg_socket_destination_port_{0u}, - inet_diag_msg_expires_{0u}, + inet_diag_msg_socket_interface_{0u}, inet_diag_msg_socket_cookie_{::uint64_t{0u}}, - inet_diag_msg_socket_dest_asn_{::uint64_t{0u}}, - inet_diag_msg_socket_next_hop_asn_{::uint64_t{0u}}, + inet_diag_msg_expires_{0u}, inet_diag_msg_rqueue_{0u}, inet_diag_msg_wqueue_{0u}, inet_diag_msg_uid_{0u}, inet_diag_msg_inode_{0u}, - inet_diag_msg_socket_dest_locality_{static_cast< ::xtcp_flat_record::v1::XtcpFlatRecord_Locality >(0)}, mem_info_rmem_{0u}, mem_info_wmem_{0u}, mem_info_fmem_{0u}, @@ -712,10 +731,10 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( tcp_info_probes_{0u}, tcp_info_backoff_{0u}, tcp_info_options_{0u}, - tcp_info_send_scale_{0u}, - tcp_info_rcv_scale_{0u}, + tcp_info_snd_wscale_{0u}, + tcp_info_rcv_wscale_{0u}, tcp_info_delivery_rate_app_limited_{0u}, - tcp_info_fast_open_client_failed_{0u}, + tcp_info_fastopen_client_fail_{0u}, tcp_info_rto_{0u}, tcp_info_ato_{0u}, tcp_info_snd_mss_{0u}, @@ -732,10 +751,10 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( tcp_info_pmtu_{0u}, tcp_info_rcv_ssthresh_{0u}, tcp_info_rtt_{0u}, - tcp_info_rtt_var_{0u}, + tcp_info_rttvar_{0u}, tcp_info_snd_ssthresh_{0u}, tcp_info_snd_cwnd_{0u}, - tcp_info_adv_mss_{0u}, + tcp_info_advmss_{0u}, tcp_info_reordering_{0u}, tcp_info_rcv_rtt_{0u}, tcp_info_rcv_space_{0u}, @@ -746,7 +765,7 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( tcp_info_bytes_acked_{::uint64_t{0u}}, tcp_info_bytes_received_{::uint64_t{0u}}, tcp_info_segs_in_{0u}, - tcp_info_not_sent_bytes_{0u}, + tcp_info_notsent_bytes_{0u}, tcp_info_min_rtt_{0u}, tcp_info_data_segs_in_{0u}, tcp_info_delivery_rate_{::uint64_t{0u}}, @@ -767,23 +786,23 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( tcp_info_total_rto_{0u}, tcp_info_total_rto_recoveries_{0u}, tcp_info_total_rto_time_{0u}, - congestion_algorithm_enum_{static_cast< ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm >(0)}, - type_of_service_{0u}, - traffic_class_{0u}, + inet_diag_cong_enum_{static_cast< ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm >(0)}, + inet_diag_tos_{0u}, + inet_diag_tclass_{0u}, sk_mem_info_rmem_alloc_{0u}, - sk_mem_info_rcv_buf_{0u}, + sk_mem_info_rcvbuf_{0u}, sk_mem_info_wmem_alloc_{0u}, - sk_mem_info_snd_buf_{0u}, + sk_mem_info_sndbuf_{0u}, sk_mem_info_fwd_alloc_{0u}, sk_mem_info_wmem_queued_{0u}, sk_mem_info_optmem_{0u}, sk_mem_info_backlog_{0u}, sk_mem_info_drops_{0u}, - shutdown_state_{0u}, + inet_diag_shutdown_{0u}, vegas_info_enabled_{0u}, - vegas_info_rtt_cnt_{0u}, + vegas_info_rttcnt_{0u}, vegas_info_rtt_{0u}, - vegas_info_min_rtt_{0u}, + vegas_info_minrtt_{0u}, dctcp_info_enabled_{0u}, dctcp_info_ce_state_{0u}, dctcp_info_alpha_{0u}, @@ -794,9 +813,9 @@ inline constexpr XtcpFlatRecord::Impl_::Impl_( bbr_info_min_rtt_{0u}, bbr_info_pacing_gain_{0u}, bbr_info_cwnd_gain_{0u}, - class_id_{0u}, - c_group_{::uint64_t{0u}}, - sock_opt_{0u} {} + inet_diag_class_id_{0u}, + inet_diag_cgroup_id_{::uint64_t{0u}}, + inet_diag_sockopt_{0u} {} template constexpr XtcpFlatRecord::XtcpFlatRecord(::_pbi::ConstantInitialized, @@ -1599,7 +1618,7 @@ const ::uint32_t 0, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_._has_bits_), - 161, // hasbit index offset + 164, // hasbit index offset PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.schema_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.daemon_version_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.timestamp_ns_), @@ -1643,6 +1662,13 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.uplink2_lldp_mgmt_ip_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.uplink2_lldp_port_id_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.uplink2_lldp_port_descr_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_interface_name_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_locality_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_egress_ifindex_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_egress_ifname_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_asn_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_next_hop_asn_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.enrich_socket_dest_network_owner_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_family_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_state_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_timer_), @@ -1653,15 +1679,11 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_destination_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_cookie_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_asn_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_next_hop_asn_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_expires_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_rqueue_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_wqueue_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_uid_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_inode_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_network_owner_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_msg_socket_dest_locality_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_rmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_wmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.mem_info_fmem_), @@ -1672,10 +1694,10 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_probes_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_backoff_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_options_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_send_scale_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rcv_scale_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_snd_wscale_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rcv_wscale_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_delivery_rate_app_limited_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_fast_open_client_failed_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_fastopen_client_fail_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rto_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_ato_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_snd_mss_), @@ -1692,10 +1714,10 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_pmtu_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rcv_ssthresh_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rtt_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rtt_var_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rttvar_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_snd_ssthresh_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_snd_cwnd_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_adv_mss_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_advmss_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_reordering_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rcv_rtt_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_rcv_space_), @@ -1706,7 +1728,7 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_bytes_received_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_segs_out_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_segs_in_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_not_sent_bytes_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_notsent_bytes_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_min_rtt_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_data_segs_in_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_data_segs_out_), @@ -1727,24 +1749,24 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_total_rto_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_total_rto_recoveries_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.tcp_info_total_rto_time_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.congestion_algorithm_string_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.congestion_algorithm_enum_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.type_of_service_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.traffic_class_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_cong_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_cong_enum_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_tos_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_tclass_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_rmem_alloc_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_rcv_buf_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_rcvbuf_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_wmem_alloc_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_snd_buf_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_sndbuf_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_fwd_alloc_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_wmem_queued_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_optmem_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_backlog_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sk_mem_info_drops_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.shutdown_state_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_shutdown_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_enabled_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_rtt_cnt_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_rttcnt_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_rtt_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_min_rtt_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.vegas_info_minrtt_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.dctcp_info_enabled_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.dctcp_info_ce_state_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.dctcp_info_alpha_), @@ -1755,9 +1777,9 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.bbr_info_min_rtt_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.bbr_info_pacing_gain_), PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.bbr_info_cwnd_gain_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.class_id_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.sock_opt_), - PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.c_group_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_class_id_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_sockopt_), + PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::XtcpFlatRecord, _impl_.inet_diag_cgroup_id_), 12, 0, 11, @@ -1774,14 +1796,14 @@ const ::uint32_t 9, 15, 16, - 42, + 44, 19, 20, 10, - 17, - 43, + 18, + 45, 21, - 44, + 46, 22, 23, 24, @@ -1791,34 +1813,34 @@ const ::uint32_t 28, 29, 30, - 45, - 46, - 31, 47, + 48, + 31, + 49, 32, 33, 34, 35, 36, 37, - 48, - 49, + 38, 50, - 51, 52, - 53, - 38, 39, - 18, + 51, + 17, + 40, + 53, + 54, 55, 56, 57, - 54, 58, + 41, + 42, 59, 60, 61, - 40, 62, 63, 64, @@ -1857,38 +1879,38 @@ const ::uint32_t 97, 98, 99, - 102, 100, 101, - 104, + 102, 105, 103, - 106, + 104, 107, 108, + 106, 109, - 112, 110, 111, - 114, + 112, 115, 113, + 114, 117, - 116, - 119, 118, + 116, 120, - 121, + 119, 122, + 121, 123, 124, 125, 126, 127, - 41, 128, 129, 130, + 43, 131, 132, 133, @@ -1914,8 +1936,11 @@ const ::uint32_t 153, 154, 155, - 157, 156, + 157, + 158, + 160, + 159, 0x000, // bitmap 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::xtcp_flat_record::v1::FlatRecordsResponse, _impl_._has_bits_), @@ -1934,10 +1959,10 @@ static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::xtcp_flat_record::v1::Envelope)}, {5, sizeof(::xtcp_flat_record::v1::XtcpFlatRecord)}, - {324, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, - {325, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, - {330, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, - {331, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, + {330, sizeof(::xtcp_flat_record::v1::FlatRecordsRequest)}, + {331, sizeof(::xtcp_flat_record::v1::FlatRecordsResponse)}, + {336, sizeof(::xtcp_flat_record::v1::PollFlatRecordsRequest)}, + {337, sizeof(::xtcp_flat_record::v1::PollFlatRecordsResponse)}, }; static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const file_message_globals[] = { @@ -1953,7 +1978,7 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr "\n*xtcp_flat_record/v1/xtcp_flat_record.p" "roto\022\023xtcp_flat_record.v1\"A\n\010Envelope\0225\n" "\003row\030\n \003(\0132#.xtcp_flat_record.v1.XtcpFla" - "tRecordR\003row\"\306>\n\016XtcpFlatRecord\022%\n\016schem" + "tRecordR\003row\"\307D\n\016XtcpFlatRecord\022%\n\016schem" "a_version\030\001 \001(\rR\rschemaVersion\022%\n\016daemon" "_version\030\002 \001(\tR\rdaemonVersion\022!\n\014timesta" "mp_ns\030\n \001(\003R\013timestampNs\022\032\n\010hostname\030\024 \001" @@ -2000,183 +2025,202 @@ const char descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5fr "_lldp_mgmt_ip\030\336\001 \001(\tR\021uplink2LldpMgmtIp\022" "0\n\024uplink2_lldp_port_id\030\337\001 \001(\tR\021uplink2L" "ldpPortId\0226\n\027uplink2_lldp_port_descr\030\340\001 " - "\001(\tR\024uplink2LldpPortDescr\0220\n\024inet_diag_m" - "sg_family\030\351\007 \001(\rR\021inetDiagMsgFamily\022.\n\023i" - "net_diag_msg_state\030\352\007 \001(\rR\020inetDiagMsgSt" - "ate\022.\n\023inet_diag_msg_timer\030\353\007 \001(\rR\020inetD" - "iagMsgTimer\0222\n\025inet_diag_msg_retrans\030\354\007 " - "\001(\rR\022inetDiagMsgRetrans\022F\n inet_diag_msg" - "_socket_source_port\030\355\007 \001(\rR\033inetDiagMsgS" - "ocketSourcePort\022P\n%inet_diag_msg_socket_" - "destination_port\030\356\007 \001(\rR inetDiagMsgSock" - "etDestinationPort\022=\n\033inet_diag_msg_socke" - "t_source\030\357\007 \001(\014R\027inetDiagMsgSocketSource" - "\022G\n inet_diag_msg_socket_destination\030\360\007 " - "\001(\014R\034inetDiagMsgSocketDestination\022C\n\036ine" - "t_diag_msg_socket_interface\030\361\007 \001(\rR\032inet" - "DiagMsgSocketInterface\022=\n\033inet_diag_msg_" - "socket_cookie\030\362\007 \001(\004R\027inetDiagMsgSocketC" - "ookie\022@\n\035inet_diag_msg_socket_dest_asn\030\363" - "\007 \001(\004R\030inetDiagMsgSocketDestAsn\022G\n!inet_" - "diag_msg_socket_next_hop_asn\030\364\007 \001(\004R\033ine" - "tDiagMsgSocketNextHopAsn\0222\n\025inet_diag_ms" - "g_expires\030\365\007 \001(\rR\022inetDiagMsgExpires\0220\n\024" - "inet_diag_msg_rqueue\030\366\007 \001(\rR\021inetDiagMsg" - "Rqueue\0220\n\024inet_diag_msg_wqueue\030\367\007 \001(\rR\021i" - "netDiagMsgWqueue\022*\n\021inet_diag_msg_uid\030\370\007" - " \001(\rR\016inetDiagMsgUid\022.\n\023inet_diag_msg_in" - "ode\030\371\007 \001(\rR\020inetDiagMsgInode\022S\n\'inet_dia" - "g_msg_socket_dest_network_owner\030\372\007 \001(\tR!" - "inetDiagMsgSocketDestNetworkOwner\022x\n\"ine" - "t_diag_msg_socket_dest_locality\030\373\007 \001(\0162," - ".xtcp_flat_record.v1.XtcpFlatRecord.Loca" - "lityR\035inetDiagMsgSocketDestLocality\022#\n\rm" - "em_info_rmem\030\315\010 \001(\rR\013memInfoRmem\022#\n\rmem_" - "info_wmem\030\316\010 \001(\rR\013memInfoWmem\022#\n\rmem_inf" - "o_fmem\030\317\010 \001(\rR\013memInfoFmem\022#\n\rmem_info_t" - "mem\030\320\010 \001(\rR\013memInfoTmem\022%\n\016tcp_info_stat" - "e\030\261\t \001(\rR\014tcpInfoState\022*\n\021tcp_info_ca_st" - "ate\030\262\t \001(\rR\016tcpInfoCaState\0221\n\024tcp_info_r" - "etransmits\030\263\t \001(\rR\022tcpInfoRetransmits\022\'\n" - "\017tcp_info_probes\030\264\t \001(\rR\rtcpInfoProbes\022)" - "\n\020tcp_info_backoff\030\265\t \001(\rR\016tcpInfoBackof" - "f\022)\n\020tcp_info_options\030\266\t \001(\rR\016tcpInfoOpt" - "ions\022.\n\023tcp_info_send_scale\030\267\t \001(\rR\020tcpI" - "nfoSendScale\022,\n\022tcp_info_rcv_scale\030\270\t \001(" - "\rR\017tcpInfoRcvScale\022J\n\"tcp_info_delivery_" - "rate_app_limited\030\271\t \001(\rR\035tcpInfoDelivery" - "RateAppLimited\022F\n tcp_info_fast_open_cli" - "ent_failed\030\272\t \001(\rR\033tcpInfoFastOpenClient" - "Failed\022!\n\014tcp_info_rto\030\277\t \001(\rR\ntcpInfoRt" - "o\022!\n\014tcp_info_ato\030\300\t \001(\rR\ntcpInfoAto\022(\n\020" - "tcp_info_snd_mss\030\301\t \001(\rR\rtcpInfoSndMss\022(" - "\n\020tcp_info_rcv_mss\030\302\t \001(\rR\rtcpInfoRcvMss" - "\022)\n\020tcp_info_unacked\030\303\t \001(\rR\016tcpInfoUnac" - "ked\022\'\n\017tcp_info_sacked\030\304\t \001(\rR\rtcpInfoSa" - "cked\022#\n\rtcp_info_lost\030\305\t \001(\rR\013tcpInfoLos" - "t\022)\n\020tcp_info_retrans\030\306\t \001(\rR\016tcpInfoRet" - "rans\022)\n\020tcp_info_fackets\030\307\t \001(\rR\016tcpInfo" - "Fackets\0225\n\027tcp_info_last_data_sent\030\310\t \001(" - "\rR\023tcpInfoLastDataSent\0223\n\026tcp_info_last_" - "ack_sent\030\311\t \001(\rR\022tcpInfoLastAckSent\0225\n\027t" - "cp_info_last_data_recv\030\312\t \001(\rR\023tcpInfoLa" - "stDataRecv\0223\n\026tcp_info_last_ack_recv\030\313\t " - "\001(\rR\022tcpInfoLastAckRecv\022#\n\rtcp_info_pmtu" - "\030\314\t \001(\rR\013tcpInfoPmtu\0222\n\025tcp_info_rcv_sst" - "hresh\030\315\t \001(\rR\022tcpInfoRcvSsthresh\022!\n\014tcp_" - "info_rtt\030\316\t \001(\rR\ntcpInfoRtt\022(\n\020tcp_info_" - "rtt_var\030\317\t \001(\rR\rtcpInfoRttVar\0222\n\025tcp_inf" - "o_snd_ssthresh\030\320\t \001(\rR\022tcpInfoSndSsthres" - "h\022*\n\021tcp_info_snd_cwnd\030\321\t \001(\rR\016tcpInfoSn" - "dCwnd\022(\n\020tcp_info_adv_mss\030\322\t \001(\rR\rtcpInf" - "oAdvMss\022/\n\023tcp_info_reordering\030\323\t \001(\rR\021t" - "cpInfoReordering\022(\n\020tcp_info_rcv_rtt\030\324\t " - "\001(\rR\rtcpInfoRcvRtt\022,\n\022tcp_info_rcv_space" - "\030\325\t \001(\rR\017tcpInfoRcvSpace\0224\n\026tcp_info_tot" - "al_retrans\030\326\t \001(\rR\023tcpInfoTotalRetrans\0220" - "\n\024tcp_info_pacing_rate\030\327\t \001(\004R\021tcpInfoPa" - "cingRate\0227\n\030tcp_info_max_pacing_rate\030\330\t " - "\001(\004R\024tcpInfoMaxPacingRate\0220\n\024tcp_info_by" - "tes_acked\030\331\t \001(\004R\021tcpInfoBytesAcked\0226\n\027t" - "cp_info_bytes_received\030\332\t \001(\004R\024tcpInfoBy" - "tesReceived\022*\n\021tcp_info_segs_out\030\333\t \001(\rR" - "\016tcpInfoSegsOut\022(\n\020tcp_info_segs_in\030\334\t \001" - "(\rR\rtcpInfoSegsIn\0225\n\027tcp_info_not_sent_b" - "ytes\030\335\t \001(\rR\023tcpInfoNotSentBytes\022(\n\020tcp_" - "info_min_rtt\030\336\t \001(\rR\rtcpInfoMinRtt\0221\n\025tc" - "p_info_data_segs_in\030\337\t \001(\rR\021tcpInfoDataS" - "egsIn\0223\n\026tcp_info_data_segs_out\030\340\t \001(\rR\022" - "tcpInfoDataSegsOut\0224\n\026tcp_info_delivery_" - "rate\030\341\t \001(\004R\023tcpInfoDeliveryRate\022,\n\022tcp_" - "info_busy_time\030\342\t \001(\004R\017tcpInfoBusyTime\0222" - "\n\025tcp_info_rwnd_limited\030\343\t \001(\004R\022tcpInfoR" - "wndLimited\0226\n\027tcp_info_sndbuf_limited\030\344\t" - " \001(\004R\024tcpInfoSndbufLimited\022-\n\022tcp_info_d" - "elivered\030\345\t \001(\rR\020tcpInfoDelivered\0222\n\025tcp" - "_info_delivered_ce\030\346\t \001(\rR\022tcpInfoDelive" - "redCe\022.\n\023tcp_info_bytes_sent\030\347\t \001(\004R\020tcp" - "InfoBytesSent\0224\n\026tcp_info_bytes_retrans\030" - "\350\t \001(\004R\023tcpInfoBytesRetrans\022.\n\023tcp_info_" - "dsack_dups\030\351\t \001(\rR\020tcpInfoDsackDups\022.\n\023t" - "cp_info_reord_seen\030\352\t \001(\rR\020tcpInfoReordS" - "een\0220\n\024tcp_info_rcv_ooopack\030\353\t \001(\rR\021tcpI" - "nfoRcvOoopack\022(\n\020tcp_info_snd_wnd\030\354\t \001(\r" - "R\rtcpInfoSndWnd\022(\n\020tcp_info_rcv_wnd\030\355\t \001" - "(\rR\rtcpInfoRcvWnd\022\'\n\017tcp_info_rehash\030\356\t " - "\001(\rR\rtcpInfoRehash\022,\n\022tcp_info_total_rto" - "\030\357\t \001(\rR\017tcpInfoTotalRto\022A\n\035tcp_info_tot" - "al_rto_recoveries\030\360\t \001(\rR\031tcpInfoTotalRt" - "oRecoveries\0225\n\027tcp_info_total_rto_time\030\361" - "\t \001(\rR\023tcpInfoTotalRtoTime\022\?\n\033congestion" - "_algorithm_string\030\224\n \001(\tR\031congestionAlgo" - "rithmString\022t\n\031congestion_algorithm_enum" - "\030\225\n \001(\01627.xtcp_flat_record.v1.XtcpFlatRe" - "cord.CongestionAlgorithmR\027congestionAlgo" - "rithmEnum\022\'\n\017type_of_service\030\371\n \001(\rR\rtyp" - "eOfService\022$\n\rtraffic_class\030\372\n \001(\rR\014traf" - "ficClass\0223\n\026sk_mem_info_rmem_alloc\030\335\013 \001(" - "\rR\022skMemInfoRmemAlloc\022-\n\023sk_mem_info_rcv" - "_buf\030\336\013 \001(\rR\017skMemInfoRcvBuf\0223\n\026sk_mem_i" - "nfo_wmem_alloc\030\337\013 \001(\rR\022skMemInfoWmemAllo" - "c\022-\n\023sk_mem_info_snd_buf\030\340\013 \001(\rR\017skMemIn" - "foSndBuf\0221\n\025sk_mem_info_fwd_alloc\030\341\013 \001(\r" - "R\021skMemInfoFwdAlloc\0225\n\027sk_mem_info_wmem_" - "queued\030\342\013 \001(\rR\023skMemInfoWmemQueued\022,\n\022sk" - "_mem_info_optmem\030\343\013 \001(\rR\017skMemInfoOptmem" - "\022.\n\023sk_mem_info_backlog\030\344\013 \001(\rR\020skMemInf" - "oBacklog\022*\n\021sk_mem_info_drops\030\345\013 \001(\rR\016sk" - "MemInfoDrops\022&\n\016shutdown_state\030\300\014 \001(\rR\rs" - "hutdownState\022-\n\022vegas_info_enabled\030\245\r \001(" - "\rR\020vegasInfoEnabled\022,\n\022vegas_info_rtt_cn" - "t\030\246\r \001(\rR\017vegasInfoRttCnt\022%\n\016vegas_info_" - "rtt\030\247\r \001(\rR\014vegasInfoRtt\022,\n\022vegas_info_m" - "in_rtt\030\250\r \001(\rR\017vegasInfoMinRtt\022-\n\022dctcp_" - "info_enabled\030\211\016 \001(\rR\020dctcpInfoEnabled\022.\n" - "\023dctcp_info_ce_state\030\212\016 \001(\rR\020dctcpInfoCe" - "State\022)\n\020dctcp_info_alpha\030\213\016 \001(\rR\016dctcpI" - "nfoAlpha\022*\n\021dctcp_info_ab_ecn\030\214\016 \001(\rR\016dc" - "tcpInfoAbEcn\022*\n\021dctcp_info_ab_tot\030\215\016 \001(\r" - "R\016dctcpInfoAbTot\022$\n\016bbr_info_bw_lo\030\355\016 \001(" - "\rR\013bbrInfoBwLo\022$\n\016bbr_info_bw_hi\030\356\016 \001(\rR" - "\013bbrInfoBwHi\022(\n\020bbr_info_min_rtt\030\357\016 \001(\rR" - "\rbbrInfoMinRtt\0220\n\024bbr_info_pacing_gain\030\360" - "\016 \001(\rR\021bbrInfoPacingGain\022,\n\022bbr_info_cwn" - "d_gain\030\361\016 \001(\rR\017bbrInfoCwndGain\022\032\n\010class_" - "id\030\321\017 \001(\rR\007classId\022\032\n\010sock_opt\030\322\017 \001(\rR\007s" - "ockOpt\022\030\n\007c_group\030\267\020 \001(\004R\006cGroup\"g\n\010Loca" - "lity\022\030\n\024LOCALITY_UNSPECIFIED\020\000\022\021\n\rLOCALI" - "TY_SELF\020\001\022\031\n\025LOCALITY_LOCAL_SUBNET\020\002\022\023\n\017" - "LOCALITY_REMOTE\020\003\"\231\002\n\023CongestionAlgorith" - "m\022$\n CONGESTION_ALGORITHM_UNSPECIFIED\020\000\022" - "\036\n\032CONGESTION_ALGORITHM_CUBIC\020\001\022\036\n\032CONGE" - "STION_ALGORITHM_DCTCP\020\002\022\036\n\032CONGESTION_AL" - "GORITHM_VEGAS\020\003\022\037\n\033CONGESTION_ALGORITHM_" - "PRAGUE\020\004\022\035\n\031CONGESTION_ALGORITHM_BBR1\020\005\022" - "\035\n\031CONGESTION_ALGORITHM_BBR2\020\006\022\035\n\031CONGES" - "TION_ALGORITHM_BBR3\020\007\"\024\n\022FlatRecordsRequ" - "est\"d\n\023FlatRecordsResponse\022M\n\020xtcp_flat_" - "record\030\001 \001(\0132#.xtcp_flat_record.v1.XtcpF" - "latRecordR\016xtcpFlatRecord\"\030\n\026PollFlatRec" - "ordsRequest\"h\n\027PollFlatRecordsResponse\022M" - "\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp_flat_rec" - "ord.v1.XtcpFlatRecordR\016xtcpFlatRecord2\355\001" - "\n\025XTCPFlatRecordService\022b\n\013FlatRecords\022\'" - ".xtcp_flat_record.v1.FlatRecordsRequest\032" - "(.xtcp_flat_record.v1.FlatRecordsRespons" - "e0\001\022p\n\017PollFlatRecords\022+.xtcp_flat_recor" - "d.v1.PollFlatRecordsRequest\032,.xtcp_flat_" - "record.v1.PollFlatRecordsResponse(\0010\001B\256\001" - "\n\027com.xtcp_flat_record.v1B\023XtcpFlatRecor" - "dProtoP\001Z\031./gen/go/xtcp_flat_record\242\002\003XX" - "X\252\002\021XtcpFlatRecord.V1\312\002\021XtcpFlatRecord\\V" - "1\342\002\035XtcpFlatRecord\\V1\\GPBMetadata\352\002\022Xtcp" - "FlatRecord::V1b\006proto3" + "\001(\tR\024uplink2LldpPortDescr\022@\n\034enrich_sock" + "et_interface_name\030\254\002 \001(\tR\031enrichSocketIn" + "terfaceName\022l\n\033enrich_socket_dest_locali" + "ty\030\266\002 \001(\0162,.xtcp_flat_record.v1.XtcpFlat" + "Record.LocalityR\030enrichSocketDestLocalit" + "y\022I\n!enrich_socket_dest_egress_ifindex\030\267" + "\002 \001(\rR\035enrichSocketDestEgressIfindex\022G\n " + "enrich_socket_dest_egress_ifname\030\270\002 \001(\tR" + "\034enrichSocketDestEgressIfname\0224\n\026enrich_" + "socket_dest_asn\030\300\002 \001(\004R\023enrichSocketDest" + "Asn\022D\n\037enrich_socket_dest_next_hop_asn\030\301" + "\002 \001(\004R\032enrichSocketDestNextHopAsn\022G\n enr" + "ich_socket_dest_network_owner\030\302\002 \001(\tR\034en" + "richSocketDestNetworkOwner\0220\n\024inet_diag_" + "msg_family\030\351\007 \001(\rR\021inetDiagMsgFamily\022.\n\023" + "inet_diag_msg_state\030\352\007 \001(\rR\020inetDiagMsgS" + "tate\022.\n\023inet_diag_msg_timer\030\353\007 \001(\rR\020inet" + "DiagMsgTimer\0222\n\025inet_diag_msg_retrans\030\354\007" + " \001(\rR\022inetDiagMsgRetrans\022F\n inet_diag_ms" + "g_socket_source_port\030\355\007 \001(\rR\033inetDiagMsg" + "SocketSourcePort\022P\n%inet_diag_msg_socket" + "_destination_port\030\356\007 \001(\rR inetDiagMsgSoc" + "ketDestinationPort\022=\n\033inet_diag_msg_sock" + "et_source\030\357\007 \001(\014R\027inetDiagMsgSocketSourc" + "e\022G\n inet_diag_msg_socket_destination\030\360\007" + " \001(\014R\034inetDiagMsgSocketDestination\022C\n\036in" + "et_diag_msg_socket_interface\030\361\007 \001(\rR\032ine" + "tDiagMsgSocketInterface\022=\n\033inet_diag_msg" + "_socket_cookie\030\362\007 \001(\004R\027inetDiagMsgSocket" + "Cookie\0222\n\025inet_diag_msg_expires\030\365\007 \001(\rR\022" + "inetDiagMsgExpires\0220\n\024inet_diag_msg_rque" + "ue\030\366\007 \001(\rR\021inetDiagMsgRqueue\0220\n\024inet_dia" + "g_msg_wqueue\030\367\007 \001(\rR\021inetDiagMsgWqueue\022*" + "\n\021inet_diag_msg_uid\030\370\007 \001(\rR\016inetDiagMsgU" + "id\022.\n\023inet_diag_msg_inode\030\371\007 \001(\rR\020inetDi" + "agMsgInode\022#\n\rmem_info_rmem\030\315\010 \001(\rR\013memI" + "nfoRmem\022#\n\rmem_info_wmem\030\316\010 \001(\rR\013memInfo" + "Wmem\022#\n\rmem_info_fmem\030\317\010 \001(\rR\013memInfoFme" + "m\022#\n\rmem_info_tmem\030\320\010 \001(\rR\013memInfoTmem\022%" + "\n\016tcp_info_state\030\261\t \001(\rR\014tcpInfoState\022*\n" + "\021tcp_info_ca_state\030\262\t \001(\rR\016tcpInfoCaStat" + "e\0221\n\024tcp_info_retransmits\030\263\t \001(\rR\022tcpInf" + "oRetransmits\022\'\n\017tcp_info_probes\030\264\t \001(\rR\r" + "tcpInfoProbes\022)\n\020tcp_info_backoff\030\265\t \001(\r" + "R\016tcpInfoBackoff\022)\n\020tcp_info_options\030\266\t " + "\001(\rR\016tcpInfoOptions\022.\n\023tcp_info_snd_wsca" + "le\030\267\t \001(\rR\020tcpInfoSndWscale\022.\n\023tcp_info_" + "rcv_wscale\030\270\t \001(\rR\020tcpInfoRcvWscale\022J\n\"t" + "cp_info_delivery_rate_app_limited\030\271\t \001(\r" + "R\035tcpInfoDeliveryRateAppLimited\022A\n\035tcp_i" + "nfo_fastopen_client_fail\030\272\t \001(\rR\031tcpInfo" + "FastopenClientFail\022!\n\014tcp_info_rto\030\277\t \001(" + "\rR\ntcpInfoRto\022!\n\014tcp_info_ato\030\300\t \001(\rR\ntc" + "pInfoAto\022(\n\020tcp_info_snd_mss\030\301\t \001(\rR\rtcp" + "InfoSndMss\022(\n\020tcp_info_rcv_mss\030\302\t \001(\rR\rt" + "cpInfoRcvMss\022)\n\020tcp_info_unacked\030\303\t \001(\rR" + "\016tcpInfoUnacked\022\'\n\017tcp_info_sacked\030\304\t \001(" + "\rR\rtcpInfoSacked\022#\n\rtcp_info_lost\030\305\t \001(\r" + "R\013tcpInfoLost\022)\n\020tcp_info_retrans\030\306\t \001(\r" + "R\016tcpInfoRetrans\022)\n\020tcp_info_fackets\030\307\t " + "\001(\rR\016tcpInfoFackets\0225\n\027tcp_info_last_dat" + "a_sent\030\310\t \001(\rR\023tcpInfoLastDataSent\0223\n\026tc" + "p_info_last_ack_sent\030\311\t \001(\rR\022tcpInfoLast" + "AckSent\0225\n\027tcp_info_last_data_recv\030\312\t \001(" + "\rR\023tcpInfoLastDataRecv\0223\n\026tcp_info_last_" + "ack_recv\030\313\t \001(\rR\022tcpInfoLastAckRecv\022#\n\rt" + "cp_info_pmtu\030\314\t \001(\rR\013tcpInfoPmtu\0222\n\025tcp_" + "info_rcv_ssthresh\030\315\t \001(\rR\022tcpInfoRcvSsth" + "resh\022!\n\014tcp_info_rtt\030\316\t \001(\rR\ntcpInfoRtt\022" + "\'\n\017tcp_info_rttvar\030\317\t \001(\rR\rtcpInfoRttvar" + "\0222\n\025tcp_info_snd_ssthresh\030\320\t \001(\rR\022tcpInf" + "oSndSsthresh\022*\n\021tcp_info_snd_cwnd\030\321\t \001(\r" + "R\016tcpInfoSndCwnd\022\'\n\017tcp_info_advmss\030\322\t \001" + "(\rR\rtcpInfoAdvmss\022/\n\023tcp_info_reordering" + "\030\323\t \001(\rR\021tcpInfoReordering\022(\n\020tcp_info_r" + "cv_rtt\030\324\t \001(\rR\rtcpInfoRcvRtt\022,\n\022tcp_info" + "_rcv_space\030\325\t \001(\rR\017tcpInfoRcvSpace\0224\n\026tc" + "p_info_total_retrans\030\326\t \001(\rR\023tcpInfoTota" + "lRetrans\0220\n\024tcp_info_pacing_rate\030\327\t \001(\004R" + "\021tcpInfoPacingRate\0227\n\030tcp_info_max_pacin" + "g_rate\030\330\t \001(\004R\024tcpInfoMaxPacingRate\0220\n\024t" + "cp_info_bytes_acked\030\331\t \001(\004R\021tcpInfoBytes" + "Acked\0226\n\027tcp_info_bytes_received\030\332\t \001(\004R" + "\024tcpInfoBytesReceived\022*\n\021tcp_info_segs_o" + "ut\030\333\t \001(\rR\016tcpInfoSegsOut\022(\n\020tcp_info_se" + "gs_in\030\334\t \001(\rR\rtcpInfoSegsIn\0224\n\026tcp_info_" + "notsent_bytes\030\335\t \001(\rR\023tcpInfoNotsentByte" + "s\022(\n\020tcp_info_min_rtt\030\336\t \001(\rR\rtcpInfoMin" + "Rtt\0221\n\025tcp_info_data_segs_in\030\337\t \001(\rR\021tcp" + "InfoDataSegsIn\0223\n\026tcp_info_data_segs_out" + "\030\340\t \001(\rR\022tcpInfoDataSegsOut\0224\n\026tcp_info_" + "delivery_rate\030\341\t \001(\004R\023tcpInfoDeliveryRat" + "e\022,\n\022tcp_info_busy_time\030\342\t \001(\004R\017tcpInfoB" + "usyTime\0222\n\025tcp_info_rwnd_limited\030\343\t \001(\004R" + "\022tcpInfoRwndLimited\0226\n\027tcp_info_sndbuf_l" + "imited\030\344\t \001(\004R\024tcpInfoSndbufLimited\022-\n\022t" + "cp_info_delivered\030\345\t \001(\rR\020tcpInfoDeliver" + "ed\0222\n\025tcp_info_delivered_ce\030\346\t \001(\rR\022tcpI" + "nfoDeliveredCe\022.\n\023tcp_info_bytes_sent\030\347\t" + " \001(\004R\020tcpInfoBytesSent\0224\n\026tcp_info_bytes" + "_retrans\030\350\t \001(\004R\023tcpInfoBytesRetrans\022.\n\023" + "tcp_info_dsack_dups\030\351\t \001(\rR\020tcpInfoDsack" + "Dups\022.\n\023tcp_info_reord_seen\030\352\t \001(\rR\020tcpI" + "nfoReordSeen\0220\n\024tcp_info_rcv_ooopack\030\353\t " + "\001(\rR\021tcpInfoRcvOoopack\022(\n\020tcp_info_snd_w" + "nd\030\354\t \001(\rR\rtcpInfoSndWnd\022(\n\020tcp_info_rcv" + "_wnd\030\355\t \001(\rR\rtcpInfoRcvWnd\022\'\n\017tcp_info_r" + "ehash\030\356\t \001(\rR\rtcpInfoRehash\022,\n\022tcp_info_" + "total_rto\030\357\t \001(\rR\017tcpInfoTotalRto\022A\n\035tcp" + "_info_total_rto_recoveries\030\360\t \001(\rR\031tcpIn" + "foTotalRtoRecoveries\0225\n\027tcp_info_total_r" + "to_time\030\361\t \001(\rR\023tcpInfoTotalRtoTime\022%\n\016i" + "net_diag_cong\030\224\n \001(\tR\014inetDiagCong\022g\n\023in" + "et_diag_cong_enum\030\225\n \001(\01627.xtcp_flat_rec" + "ord.v1.XtcpFlatRecord.CongestionAlgorith" + "mR\020inetDiagCongEnum\022#\n\rinet_diag_tos\030\371\n " + "\001(\rR\013inetDiagTos\022)\n\020inet_diag_tclass\030\372\n " + "\001(\rR\016inetDiagTclass\0223\n\026sk_mem_info_rmem_" + "alloc\030\335\013 \001(\rR\022skMemInfoRmemAlloc\022,\n\022sk_m" + "em_info_rcvbuf\030\336\013 \001(\rR\017skMemInfoRcvbuf\0223" + "\n\026sk_mem_info_wmem_alloc\030\337\013 \001(\rR\022skMemIn" + "foWmemAlloc\022,\n\022sk_mem_info_sndbuf\030\340\013 \001(\r" + "R\017skMemInfoSndbuf\0221\n\025sk_mem_info_fwd_all" + "oc\030\341\013 \001(\rR\021skMemInfoFwdAlloc\0225\n\027sk_mem_i" + "nfo_wmem_queued\030\342\013 \001(\rR\023skMemInfoWmemQue" + "ued\022,\n\022sk_mem_info_optmem\030\343\013 \001(\rR\017skMemI" + "nfoOptmem\022.\n\023sk_mem_info_backlog\030\344\013 \001(\rR" + "\020skMemInfoBacklog\022*\n\021sk_mem_info_drops\030\345" + "\013 \001(\rR\016skMemInfoDrops\022-\n\022inet_diag_shutd" + "own\030\300\014 \001(\rR\020inetDiagShutdown\022-\n\022vegas_in" + "fo_enabled\030\245\r \001(\rR\020vegasInfoEnabled\022+\n\021v" + "egas_info_rttcnt\030\246\r \001(\rR\017vegasInfoRttcnt" + "\022%\n\016vegas_info_rtt\030\247\r \001(\rR\014vegasInfoRtt\022" + "+\n\021vegas_info_minrtt\030\250\r \001(\rR\017vegasInfoMi" + "nrtt\022-\n\022dctcp_info_enabled\030\211\016 \001(\rR\020dctcp" + "InfoEnabled\022.\n\023dctcp_info_ce_state\030\212\016 \001(" + "\rR\020dctcpInfoCeState\022)\n\020dctcp_info_alpha\030" + "\213\016 \001(\rR\016dctcpInfoAlpha\022*\n\021dctcp_info_ab_" + "ecn\030\214\016 \001(\rR\016dctcpInfoAbEcn\022*\n\021dctcp_info" + "_ab_tot\030\215\016 \001(\rR\016dctcpInfoAbTot\022$\n\016bbr_in" + "fo_bw_lo\030\355\016 \001(\rR\013bbrInfoBwLo\022$\n\016bbr_info" + "_bw_hi\030\356\016 \001(\rR\013bbrInfoBwHi\022(\n\020bbr_info_m" + "in_rtt\030\357\016 \001(\rR\rbbrInfoMinRtt\0220\n\024bbr_info" + "_pacing_gain\030\360\016 \001(\rR\021bbrInfoPacingGain\022," + "\n\022bbr_info_cwnd_gain\030\361\016 \001(\rR\017bbrInfoCwnd" + "Gain\022,\n\022inet_diag_class_id\030\321\017 \001(\rR\017inetD" + "iagClassId\022+\n\021inet_diag_sockopt\030\322\017 \001(\rR\017" + "inetDiagSockopt\022.\n\023inet_diag_cgroup_id\030\323" + "\017 \001(\004R\020inetDiagCgroupId\"g\n\010Locality\022\030\n\024L" + "OCALITY_UNSPECIFIED\020\000\022\021\n\rLOCALITY_SELF\020\001" + "\022\031\n\025LOCALITY_LOCAL_SUBNET\020\002\022\023\n\017LOCALITY_" + "REMOTE\020\003\"\231\002\n\023CongestionAlgorithm\022$\n CONG" + "ESTION_ALGORITHM_UNSPECIFIED\020\000\022\036\n\032CONGES" + "TION_ALGORITHM_CUBIC\020\001\022\036\n\032CONGESTION_ALG" + "ORITHM_DCTCP\020\002\022\036\n\032CONGESTION_ALGORITHM_V" + "EGAS\020\003\022\037\n\033CONGESTION_ALGORITHM_PRAGUE\020\004\022" + "\035\n\031CONGESTION_ALGORITHM_BBR1\020\005\022\035\n\031CONGES" + "TION_ALGORITHM_BBR2\020\006\022\035\n\031CONGESTION_ALGO" + "RITHM_BBR3\020\007J\006\010\255\002\020\256\002J\006\010\256\002\020\257\002J\006\010\363\007\020\364\007J\006\010\364" + "\007\020\365\007J\006\010\372\007\020\373\007J\006\010\373\007\020\374\007J\006\010\267\020\020\270\020R\035inet_diag_" + "msg_socket_dest_asnR!inet_diag_msg_socke" + "t_next_hop_asnR\'inet_diag_msg_socket_des" + "t_network_ownerR\"inet_diag_msg_socket_de" + "st_localityR\032enrich_socket_next_hop_asnR" + "\023tcp_info_send_scaleR\022tcp_info_rcv_scale" + "R tcp_info_fast_open_client_failedR\020tcp_" + "info_rtt_varR\020tcp_info_adv_mssR\027tcp_info" + "_not_sent_bytesR\023sk_mem_info_rcv_bufR\023sk" + "_mem_info_snd_bufR\022vegas_info_rtt_cntR\022v" + "egas_info_min_rttR\033congestion_algorithm_" + "stringR\031congestion_algorithm_enumR\017type_" + "of_serviceR\rtraffic_classR\016shutdown_stat" + "eR\010class_idR\010sock_optR\007c_group\"\024\n\022FlatRe" + "cordsRequest\"d\n\023FlatRecordsResponse\022M\n\020x" + "tcp_flat_record\030\001 \001(\0132#.xtcp_flat_record" + ".v1.XtcpFlatRecordR\016xtcpFlatRecord\"\030\n\026Po" + "llFlatRecordsRequest\"h\n\027PollFlatRecordsR" + "esponse\022M\n\020xtcp_flat_record\030\001 \001(\0132#.xtcp" + "_flat_record.v1.XtcpFlatRecordR\016xtcpFlat" + "Record2\355\001\n\025XTCPFlatRecordService\022b\n\013Flat" + "Records\022\'.xtcp_flat_record.v1.FlatRecord" + "sRequest\032(.xtcp_flat_record.v1.FlatRecor" + "dsResponse0\001\022p\n\017PollFlatRecords\022+.xtcp_f" + "lat_record.v1.PollFlatRecordsRequest\032,.x" + "tcp_flat_record.v1.PollFlatRecordsRespon" + "se(\0010\001B\256\001\n\027com.xtcp_flat_record.v1B\023Xtcp" + "FlatRecordProtoP\001Z\031./gen/go/xtcp_flat_re" + "cord\242\002\003XXX\252\002\021XtcpFlatRecord.V1\312\002\021XtcpFla" + "tRecord\\V1\342\002\035XtcpFlatRecord\\V1\\GPBMetada" + "ta\352\002\022XtcpFlatRecord::V1b\006proto3" }; static ::absl::once_flag descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto = { false, false, - 8822, + 9591, descriptor_table_protodef_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto, "xtcp_flat_record/v1/xtcp_flat_record.proto", &descriptor_table_xtcp_5fflat_5frecord_2fv1_2fxtcp_5fflat_5frecord_2eproto_once, @@ -2474,10 +2518,12 @@ PROTOBUF_NDEBUG_INLINE XtcpFlatRecord::Impl_::Impl_( uplink2_lldp_mgmt_ip_(arena, from.uplink2_lldp_mgmt_ip_), uplink2_lldp_port_id_(arena, from.uplink2_lldp_port_id_), uplink2_lldp_port_descr_(arena, from.uplink2_lldp_port_descr_), + enrich_socket_interface_name_(arena, from.enrich_socket_interface_name_), + enrich_socket_dest_egress_ifname_(arena, from.enrich_socket_dest_egress_ifname_), + enrich_socket_dest_network_owner_(arena, from.enrich_socket_dest_network_owner_), inet_diag_msg_socket_source_(arena, from.inet_diag_msg_socket_source_), inet_diag_msg_socket_destination_(arena, from.inet_diag_msg_socket_destination_), - inet_diag_msg_socket_dest_network_owner_(arena, from.inet_diag_msg_socket_dest_network_owner_), - congestion_algorithm_string_(arena, from.congestion_algorithm_string_) {} + inet_diag_cong_(arena, from.inet_diag_cong_) {} XtcpFlatRecord::XtcpFlatRecord( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, @@ -2497,16 +2543,16 @@ XtcpFlatRecord::XtcpFlatRecord( offsetof(Impl_, timestamp_ns_), reinterpret_cast(&from._impl_) + offsetof(Impl_, timestamp_ns_), - offsetof(Impl_, inet_diag_msg_socket_interface_) - + offsetof(Impl_, uplink1_nic_pci_vendor_) - offsetof(Impl_, timestamp_ns_) + - sizeof(Impl_::inet_diag_msg_socket_interface_)); + sizeof(Impl_::uplink1_nic_pci_vendor_)); ::memcpy(reinterpret_cast(&_impl_) + offsetof(Impl_, netlinker_id_), reinterpret_cast(&from._impl_) + offsetof(Impl_, netlinker_id_), - offsetof(Impl_, sock_opt_) - + offsetof(Impl_, inet_diag_sockopt_) - offsetof(Impl_, netlinker_id_) + - sizeof(Impl_::sock_opt_)); + sizeof(Impl_::inet_diag_sockopt_)); // @@protoc_insertion_point(copy_constructor:xtcp_flat_record.v1.XtcpFlatRecord) } @@ -2544,25 +2590,27 @@ PROTOBUF_NDEBUG_INLINE XtcpFlatRecord::Impl_::Impl_( uplink2_lldp_mgmt_ip_(arena), uplink2_lldp_port_id_(arena), uplink2_lldp_port_descr_(arena), + enrich_socket_interface_name_(arena), + enrich_socket_dest_egress_ifname_(arena), + enrich_socket_dest_network_owner_(arena), inet_diag_msg_socket_source_(arena), inet_diag_msg_socket_destination_(arena), - inet_diag_msg_socket_dest_network_owner_(arena), - congestion_algorithm_string_(arena) {} + inet_diag_cong_(arena) {} inline void XtcpFlatRecord::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, timestamp_ns_), 0, - offsetof(Impl_, inet_diag_msg_socket_interface_) - + offsetof(Impl_, uplink1_nic_pci_vendor_) - offsetof(Impl_, timestamp_ns_) + - sizeof(Impl_::inet_diag_msg_socket_interface_)); + sizeof(Impl_::uplink1_nic_pci_vendor_)); ::memset(reinterpret_cast(&_impl_) + offsetof(Impl_, netlinker_id_), 0, - offsetof(Impl_, sock_opt_) - + offsetof(Impl_, inet_diag_sockopt_) - offsetof(Impl_, netlinker_id_) + - sizeof(Impl_::sock_opt_)); + sizeof(Impl_::inet_diag_sockopt_)); } XtcpFlatRecord::~XtcpFlatRecord() { // @@protoc_insertion_point(destructor:xtcp_flat_record.v1.XtcpFlatRecord) @@ -2605,10 +2653,12 @@ inline void XtcpFlatRecord::SharedDtor(MessageLite& self) { this_._impl_.uplink2_lldp_mgmt_ip_.Destroy(); this_._impl_.uplink2_lldp_port_id_.Destroy(); this_._impl_.uplink2_lldp_port_descr_.Destroy(); + this_._impl_.enrich_socket_interface_name_.Destroy(); + this_._impl_.enrich_socket_dest_egress_ifname_.Destroy(); + this_._impl_.enrich_socket_dest_network_owner_.Destroy(); this_._impl_.inet_diag_msg_socket_source_.Destroy(); this_._impl_.inet_diag_msg_socket_destination_.Destroy(); - this_._impl_.inet_diag_msg_socket_dest_network_owner_.Destroy(); - this_._impl_.congestion_algorithm_string_.Destroy(); + this_._impl_.inet_diag_cong_.Destroy(); this_._impl_.~Impl_(); } @@ -2690,8 +2740,8 @@ PROTOBUF_NOINLINE void XtcpFlatRecord::Clear() { } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { ::memset(&_impl_.socket_fd_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.inet_diag_msg_socket_interface_) - - reinterpret_cast(&_impl_.socket_fd_)) + sizeof(_impl_.inet_diag_msg_socket_interface_)); + reinterpret_cast(&_impl_.uplink1_nic_pci_vendor_) - + reinterpret_cast(&_impl_.socket_fd_)) + sizeof(_impl_.uplink1_nic_pci_vendor_)); if (CheckHasBit(cached_has_bits, 0x00080000U)) { _impl_.uplink1_ifname_.ClearNonDefaultToEmpty(); } @@ -2755,98 +2805,105 @@ PROTOBUF_NOINLINE void XtcpFlatRecord::Clear() { _impl_.uplink2_lldp_port_descr_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000040U)) { - _impl_.inet_diag_msg_socket_source_.ClearNonDefaultToEmpty(); + _impl_.enrich_socket_interface_name_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000080U)) { - _impl_.inet_diag_msg_socket_destination_.ClearNonDefaultToEmpty(); + _impl_.enrich_socket_dest_egress_ifname_.ClearNonDefaultToEmpty(); } } - if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000f00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - _impl_.inet_diag_msg_socket_dest_network_owner_.ClearNonDefaultToEmpty(); + _impl_.enrich_socket_dest_network_owner_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000200U)) { - _impl_.congestion_algorithm_string_.ClearNonDefaultToEmpty(); + _impl_.inet_diag_msg_socket_source_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000400U)) { + _impl_.inet_diag_msg_socket_destination_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + _impl_.inet_diag_cong_.ClearNonDefaultToEmpty(); } } - if (BatchCheckHasBit(cached_has_bits, 0x0000fc00U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000f000U)) { ::memset(&_impl_.netlinker_id_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.uplink2_nic_speed_mbps_) - - reinterpret_cast(&_impl_.netlinker_id_)) + sizeof(_impl_.uplink2_nic_speed_mbps_)); + reinterpret_cast(&_impl_.uplink2_nic_pci_vendor_) - + reinterpret_cast(&_impl_.netlinker_id_)) + sizeof(_impl_.uplink2_nic_pci_vendor_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.inet_diag_msg_family_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.inet_diag_msg_socket_cookie_) - - reinterpret_cast(&_impl_.inet_diag_msg_family_)) + sizeof(_impl_.inet_diag_msg_socket_cookie_)); + ::memset(&_impl_.uplink2_nic_pci_device_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.inet_diag_msg_timer_) - + reinterpret_cast(&_impl_.uplink2_nic_pci_device_)) + sizeof(_impl_.inet_diag_msg_timer_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.inet_diag_msg_socket_dest_asn_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.mem_info_rmem_) - - reinterpret_cast(&_impl_.inet_diag_msg_socket_dest_asn_)) + sizeof(_impl_.mem_info_rmem_)); + ::memset(&_impl_.inet_diag_msg_retrans_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.inet_diag_msg_wqueue_) - + reinterpret_cast(&_impl_.inet_diag_msg_retrans_)) + sizeof(_impl_.inet_diag_msg_wqueue_)); } cached_has_bits = _impl_._has_bits_[2]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.mem_info_wmem_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_backoff_) - - reinterpret_cast(&_impl_.mem_info_wmem_)) + sizeof(_impl_.tcp_info_backoff_)); + ::memset(&_impl_.inet_diag_msg_uid_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_ca_state_) - + reinterpret_cast(&_impl_.inet_diag_msg_uid_)) + sizeof(_impl_.tcp_info_ca_state_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_options_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_snd_mss_) - - reinterpret_cast(&_impl_.tcp_info_options_)) + sizeof(_impl_.tcp_info_snd_mss_)); + ::memset(&_impl_.tcp_info_retransmits_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_fastopen_client_fail_) - + reinterpret_cast(&_impl_.tcp_info_retransmits_)) + sizeof(_impl_.tcp_info_fastopen_client_fail_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_rcv_mss_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_last_ack_sent_) - - reinterpret_cast(&_impl_.tcp_info_rcv_mss_)) + sizeof(_impl_.tcp_info_last_ack_sent_)); + ::memset(&_impl_.tcp_info_rto_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_retrans_) - + reinterpret_cast(&_impl_.tcp_info_rto_)) + sizeof(_impl_.tcp_info_retrans_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_last_data_recv_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_snd_cwnd_) - - reinterpret_cast(&_impl_.tcp_info_last_data_recv_)) + sizeof(_impl_.tcp_info_snd_cwnd_)); + ::memset(&_impl_.tcp_info_fackets_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_rtt_) - + reinterpret_cast(&_impl_.tcp_info_fackets_)) + sizeof(_impl_.tcp_info_rtt_)); } cached_has_bits = _impl_._has_bits_[3]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.tcp_info_adv_mss_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_segs_out_) - - reinterpret_cast(&_impl_.tcp_info_adv_mss_)) + sizeof(_impl_.tcp_info_segs_out_)); + ::memset(&_impl_.tcp_info_rttvar_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_pacing_rate_) - + reinterpret_cast(&_impl_.tcp_info_rttvar_)) + sizeof(_impl_.tcp_info_pacing_rate_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.tcp_info_bytes_acked_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_busy_time_) - - reinterpret_cast(&_impl_.tcp_info_bytes_acked_)) + sizeof(_impl_.tcp_info_busy_time_)); + ::memset(&_impl_.tcp_info_max_pacing_rate_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_min_rtt_) - + reinterpret_cast(&_impl_.tcp_info_max_pacing_rate_)) + sizeof(_impl_.tcp_info_min_rtt_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.tcp_info_data_segs_out_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_bytes_retrans_) - - reinterpret_cast(&_impl_.tcp_info_data_segs_out_)) + sizeof(_impl_.tcp_info_bytes_retrans_)); + ::memset(&_impl_.tcp_info_data_segs_in_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_bytes_sent_) - + reinterpret_cast(&_impl_.tcp_info_data_segs_in_)) + sizeof(_impl_.tcp_info_bytes_sent_)); } if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - ::memset(&_impl_.tcp_info_reord_seen_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.tcp_info_total_rto_time_) - - reinterpret_cast(&_impl_.tcp_info_reord_seen_)) + sizeof(_impl_.tcp_info_total_rto_time_)); + ::memset(&_impl_.tcp_info_delivered_ce_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.tcp_info_rehash_) - + reinterpret_cast(&_impl_.tcp_info_delivered_ce_)) + sizeof(_impl_.tcp_info_rehash_)); } cached_has_bits = _impl_._has_bits_[4]; if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - ::memset(&_impl_.congestion_algorithm_enum_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.sk_mem_info_fwd_alloc_) - - reinterpret_cast(&_impl_.congestion_algorithm_enum_)) + sizeof(_impl_.sk_mem_info_fwd_alloc_)); + ::memset(&_impl_.tcp_info_total_rto_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.sk_mem_info_rcvbuf_) - + reinterpret_cast(&_impl_.tcp_info_total_rto_)) + sizeof(_impl_.sk_mem_info_rcvbuf_)); } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - ::memset(&_impl_.sk_mem_info_wmem_queued_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.vegas_info_rtt_) - - reinterpret_cast(&_impl_.sk_mem_info_wmem_queued_)) + sizeof(_impl_.vegas_info_rtt_)); + ::memset(&_impl_.sk_mem_info_wmem_alloc_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.inet_diag_shutdown_) - + reinterpret_cast(&_impl_.sk_mem_info_wmem_alloc_)) + sizeof(_impl_.inet_diag_shutdown_)); } if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - ::memset(&_impl_.vegas_info_min_rtt_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.bbr_info_bw_hi_) - - reinterpret_cast(&_impl_.vegas_info_min_rtt_)) + sizeof(_impl_.bbr_info_bw_hi_)); + ::memset(&_impl_.vegas_info_enabled_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.dctcp_info_ab_ecn_) - + reinterpret_cast(&_impl_.vegas_info_enabled_)) + sizeof(_impl_.dctcp_info_ab_ecn_)); } - if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { - ::memset(&_impl_.bbr_info_min_rtt_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.sock_opt_) - - reinterpret_cast(&_impl_.bbr_info_min_rtt_)) + sizeof(_impl_.sock_opt_)); + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + ::memset(&_impl_.dctcp_info_ab_tot_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.inet_diag_cgroup_id_) - + reinterpret_cast(&_impl_.dctcp_info_ab_tot_)) + sizeof(_impl_.inet_diag_cgroup_id_)); } + _impl_.inet_diag_sockopt_ = 0u; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } @@ -3026,7 +3083,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_netlinker_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3066,7 +3123,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_uplink1_nic_pci_vendor() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3076,7 +3133,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_uplink1_nic_pci_device() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3097,7 +3154,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_uplink1_nic_speed_mbps() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3198,7 +3255,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_uplink2_nic_pci_vendor() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3207,7 +3264,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_uplink2_nic_pci_device() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3228,7 +3285,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( cached_has_bits = this_._impl_._has_bits_[1]; // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_uplink2_nic_speed_mbps() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3296,8 +3353,76 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + // string enrich_socket_interface_name = 300 [json_name = "enrichSocketInterfaceName"]; + if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (!this_._internal_enrich_socket_interface_name().empty()) { + const ::std::string& _s = this_._internal_enrich_socket_interface_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name"); + target = stream->WriteStringMaybeAliased(300, _s, target); + } + } + + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality enrich_socket_dest_locality = 310 [json_name = "enrichSocketDestLocality"]; + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (this_._internal_enrich_socket_dest_locality() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 310, this_._internal_enrich_socket_dest_locality(), target); + } + } + + // uint32 enrich_socket_dest_egress_ifindex = 311 [json_name = "enrichSocketDestEgressIfindex"]; + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (this_._internal_enrich_socket_dest_egress_ifindex() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 311, this_._internal_enrich_socket_dest_egress_ifindex(), target); + } + } + + // string enrich_socket_dest_egress_ifname = 312 [json_name = "enrichSocketDestEgressIfname"]; + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (!this_._internal_enrich_socket_dest_egress_ifname().empty()) { + const ::std::string& _s = this_._internal_enrich_socket_dest_egress_ifname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname"); + target = stream->WriteStringMaybeAliased(312, _s, target); + } + } + + // uint64 enrich_socket_dest_asn = 320 [json_name = "enrichSocketDestAsn"]; + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (this_._internal_enrich_socket_dest_asn() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 320, this_._internal_enrich_socket_dest_asn(), target); + } + } + + cached_has_bits = this_._impl_._has_bits_[0]; + // uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (this_._internal_enrich_socket_dest_next_hop_asn() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 321, this_._internal_enrich_socket_dest_next_hop_asn(), target); + } + } + + cached_has_bits = this_._impl_._has_bits_[1]; + // string enrich_socket_dest_network_owner = 322 [json_name = "enrichSocketDestNetworkOwner"]; + if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (!this_._internal_enrich_socket_dest_network_owner().empty()) { + const ::std::string& _s = this_._internal_enrich_socket_dest_network_owner(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner"); + target = stream->WriteStringMaybeAliased(322, _s, target); + } + } + // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_inet_diag_msg_family() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3306,7 +3431,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_inet_diag_msg_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3315,7 +3440,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_inet_diag_msg_timer() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3324,7 +3449,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_inet_diag_msg_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3333,7 +3458,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_inet_diag_msg_socket_source_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3342,7 +3467,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_inet_diag_msg_socket_destination_port() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3351,7 +3476,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (!this_._internal_inet_diag_msg_socket_source().empty()) { const ::std::string& _s = this_._internal_inet_diag_msg_socket_source(); target = stream->WriteBytesMaybeAliased(1007, _s, target); @@ -3359,16 +3484,15 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // bytes inet_diag_msg_socket_destination = 1008 [json_name = "inetDiagMsgSocketDestination"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (!this_._internal_inet_diag_msg_socket_destination().empty()) { const ::std::string& _s = this_._internal_inet_diag_msg_socket_destination(); target = stream->WriteBytesMaybeAliased(1008, _s, target); } } - cached_has_bits = this_._impl_._has_bits_[0]; // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_inet_diag_msg_socket_interface() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3376,9 +3500,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[1]; // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_inet_diag_msg_socket_cookie() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3386,26 +3509,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (this_._internal_inet_diag_msg_socket_dest_asn() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 1011, this_._internal_inet_diag_msg_socket_dest_asn(), target); - } - } - - // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (this_._internal_inet_diag_msg_socket_next_hop_asn() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 1012, this_._internal_inet_diag_msg_socket_next_hop_asn(), target); - } - } - // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_inet_diag_msg_expires() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3414,7 +3519,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_inet_diag_msg_rqueue() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3423,7 +3528,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_inet_diag_msg_wqueue() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3431,8 +3536,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[2]; // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_inet_diag_msg_uid() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3441,7 +3547,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_inet_diag_msg_inode() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3449,27 +3555,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (!this_._internal_inet_diag_msg_socket_dest_network_owner().empty()) { - const ::std::string& _s = this_._internal_inet_diag_msg_socket_dest_network_owner(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner"); - target = stream->WriteStringMaybeAliased(1018, _s, target); - } - } - - // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (this_._internal_inet_diag_msg_socket_dest_locality() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1019, this_._internal_inet_diag_msg_socket_dest_locality(), target); - } - } - // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_mem_info_rmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3477,9 +3564,8 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[2]; // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_mem_info_wmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3488,7 +3574,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_mem_info_fmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3497,7 +3583,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_mem_info_tmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3506,7 +3592,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3515,7 +3601,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_ca_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3524,7 +3610,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_retransmits() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3533,7 +3619,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_probes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3542,7 +3628,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_backoff() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3551,7 +3637,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_options() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3559,26 +3645,26 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (this_._internal_tcp_info_send_scale() != 0) { + // uint32 tcp_info_snd_wscale = 1207 [json_name = "tcpInfoSndWscale"]; + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (this_._internal_tcp_info_snd_wscale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1207, this_._internal_tcp_info_send_scale(), target); + 1207, this_._internal_tcp_info_snd_wscale(), target); } } - // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (this_._internal_tcp_info_rcv_scale() != 0) { + // uint32 tcp_info_rcv_wscale = 1208 [json_name = "tcpInfoRcvWscale"]; + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (this_._internal_tcp_info_rcv_wscale() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1208, this_._internal_tcp_info_rcv_scale(), target); + 1208, this_._internal_tcp_info_rcv_wscale(), target); } } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3586,17 +3672,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (this_._internal_tcp_info_fast_open_client_failed() != 0) { + // uint32 tcp_info_fastopen_client_fail = 1210 [json_name = "tcpInfoFastopenClientFail"]; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (this_._internal_tcp_info_fastopen_client_fail() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1210, this_._internal_tcp_info_fast_open_client_failed(), target); + 1210, this_._internal_tcp_info_fastopen_client_fail(), target); } } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3605,7 +3691,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_ato() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3614,7 +3700,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3623,7 +3709,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3632,7 +3718,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_unacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3641,7 +3727,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_sacked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3650,7 +3736,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_lost() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3659,7 +3745,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3668,7 +3754,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_fackets() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3677,7 +3763,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3686,7 +3772,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3695,7 +3781,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3704,7 +3790,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3713,7 +3799,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3722,7 +3808,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3731,7 +3817,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3739,17 +3825,18 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_tcp_info_rtt_var() != 0) { + cached_has_bits = this_._impl_._has_bits_[3]; + // uint32 tcp_info_rttvar = 1231 [json_name = "tcpInfoRttvar"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (this_._internal_tcp_info_rttvar() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1231, this_._internal_tcp_info_rtt_var(), target); + 1231, this_._internal_tcp_info_rttvar(), target); } } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3758,7 +3845,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3766,18 +3853,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - cached_has_bits = this_._impl_._has_bits_[3]; - // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (this_._internal_tcp_info_adv_mss() != 0) { + // uint32 tcp_info_advmss = 1234 [json_name = "tcpInfoAdvmss"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_tcp_info_advmss() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1234, this_._internal_tcp_info_adv_mss(), target); + 1234, this_._internal_tcp_info_advmss(), target); } } // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_reordering() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3786,7 +3872,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3795,7 +3881,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_rcv_space() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3804,7 +3890,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_total_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3813,7 +3899,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_pacing_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3822,7 +3908,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_max_pacing_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3831,7 +3917,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3840,7 +3926,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_bytes_received() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3849,7 +3935,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3858,7 +3944,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3866,17 +3952,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (this_._internal_tcp_info_not_sent_bytes() != 0) { + // uint32 tcp_info_notsent_bytes = 1245 [json_name = "tcpInfoNotsentBytes"]; + if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (this_._internal_tcp_info_notsent_bytes() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1245, this_._internal_tcp_info_not_sent_bytes(), target); + 1245, this_._internal_tcp_info_notsent_bytes(), target); } } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3885,7 +3971,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3894,7 +3980,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_data_segs_out() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3903,7 +3989,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_delivery_rate() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3912,7 +3998,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_busy_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3921,7 +4007,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_rwnd_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3930,7 +4016,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_sndbuf_limited() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3939,7 +4025,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_delivered() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3948,7 +4034,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_delivered_ce() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3957,7 +4043,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_bytes_sent() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3966,7 +4052,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_bytes_retrans() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( @@ -3975,7 +4061,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_dsack_dups() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3984,7 +4070,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -3993,7 +4079,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4002,7 +4088,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4011,7 +4097,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4020,7 +4106,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_rehash() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4028,8 +4114,9 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } + cached_has_bits = this_._impl_._has_bits_[4]; // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_total_rto() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4038,7 +4125,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4047,7 +4134,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4056,46 +4143,46 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } cached_has_bits = this_._impl_._has_bits_[1]; - // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (!this_._internal_congestion_algorithm_string().empty()) { - const ::std::string& _s = this_._internal_congestion_algorithm_string(); + // string inet_diag_cong = 1300 [json_name = "inetDiagCong"]; + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (!this_._internal_inet_diag_cong().empty()) { + const ::std::string& _s = this_._internal_inet_diag_cong(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string"); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong"); target = stream->WriteStringMaybeAliased(1300, _s, target); } } cached_has_bits = this_._impl_._has_bits_[4]; - // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (this_._internal_congestion_algorithm_enum() != 0) { + // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm inet_diag_cong_enum = 1301 [json_name = "inetDiagCongEnum"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_inet_diag_cong_enum() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1301, this_._internal_congestion_algorithm_enum(), target); + 1301, this_._internal_inet_diag_cong_enum(), target); } } - // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_type_of_service() != 0) { + // uint32 inet_diag_tos = 1401 [json_name = "inetDiagTos"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_inet_diag_tos() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1401, this_._internal_type_of_service(), target); + 1401, this_._internal_inet_diag_tos(), target); } } - // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_traffic_class() != 0) { + // uint32 inet_diag_tclass = 1402 [json_name = "inetDiagTclass"]; + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (this_._internal_inet_diag_tclass() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1402, this_._internal_traffic_class(), target); + 1402, this_._internal_inet_diag_tclass(), target); } } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4103,17 +4190,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (this_._internal_sk_mem_info_rcv_buf() != 0) { + // uint32 sk_mem_info_rcvbuf = 1502 [json_name = "skMemInfoRcvbuf"]; + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (this_._internal_sk_mem_info_rcvbuf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1502, this_._internal_sk_mem_info_rcv_buf(), target); + 1502, this_._internal_sk_mem_info_rcvbuf(), target); } } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4121,17 +4208,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (this_._internal_sk_mem_info_snd_buf() != 0) { + // uint32 sk_mem_info_sndbuf = 1504 [json_name = "skMemInfoSndbuf"]; + if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (this_._internal_sk_mem_info_sndbuf() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1504, this_._internal_sk_mem_info_snd_buf(), target); + 1504, this_._internal_sk_mem_info_sndbuf(), target); } } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4140,7 +4227,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4149,7 +4236,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_sk_mem_info_optmem() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4158,7 +4245,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_sk_mem_info_backlog() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4167,7 +4254,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_sk_mem_info_drops() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4175,17 +4262,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (this_._internal_shutdown_state() != 0) { + // uint32 inet_diag_shutdown = 1600 [json_name = "inetDiagShutdown"]; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (this_._internal_inet_diag_shutdown() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1600, this_._internal_shutdown_state(), target); + 1600, this_._internal_inet_diag_shutdown(), target); } } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_vegas_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4193,17 +4280,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_vegas_info_rtt_cnt() != 0) { + // uint32 vegas_info_rttcnt = 1702 [json_name = "vegasInfoRttcnt"]; + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (this_._internal_vegas_info_rttcnt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1702, this_._internal_vegas_info_rtt_cnt(), target); + 1702, this_._internal_vegas_info_rttcnt(), target); } } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_vegas_info_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4211,17 +4298,17 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_vegas_info_min_rtt() != 0) { + // uint32 vegas_info_minrtt = 1704 [json_name = "vegasInfoMinrtt"]; + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (this_._internal_vegas_info_minrtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1704, this_._internal_vegas_info_min_rtt(), target); + 1704, this_._internal_vegas_info_minrtt(), target); } } // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_enabled() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4230,7 +4317,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4239,7 +4326,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_dctcp_info_alpha() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4248,7 +4335,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4257,7 +4344,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4266,7 +4353,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4275,7 +4362,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4284,7 +4371,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4293,7 +4380,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4302,7 +4389,7 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( @@ -4310,30 +4397,32 @@ ::uint8_t* PROTOBUF_NONNULL XtcpFlatRecord::_InternalSerialize( } } - // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (this_._internal_class_id() != 0) { + // uint32 inet_diag_class_id = 2001 [json_name = "inetDiagClassId"]; + if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (this_._internal_inet_diag_class_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2001, this_._internal_class_id(), target); + 2001, this_._internal_inet_diag_class_id(), target); } } - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_sock_opt() != 0) { + cached_has_bits = this_._impl_._has_bits_[5]; + // uint32 inet_diag_sockopt = 2002 [json_name = "inetDiagSockopt"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (this_._internal_inet_diag_sockopt() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2002, this_._internal_sock_opt(), target); + 2002, this_._internal_inet_diag_sockopt(), target); } } - // uint64 c_group = 2103 [json_name = "cGroup"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (this_._internal_c_group() != 0) { + cached_has_bits = this_._impl_._has_bits_[4]; + // uint64 inet_diag_cgroup_id = 2003 [json_name = "inetDiagCgroupId"]; + if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (this_._internal_inet_diag_cgroup_id() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 2103, this_._internal_c_group(), target); + 2003, this_._internal_inet_diag_cgroup_id(), target); } } @@ -4486,18 +4575,18 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_socket_fd()); } } - // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; + // uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (this_._internal_uplink1_nic_pci_vendor() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_uplink1_nic_pci_vendor()); + if (this_._internal_enrich_socket_dest_next_hop_asn() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_enrich_socket_dest_next_hop_asn()); } } - // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; + // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (this_._internal_inet_diag_msg_socket_interface() != 0) { + if (this_._internal_uplink1_nic_pci_vendor() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_inet_diag_msg_socket_interface()); + this_._internal_uplink1_nic_pci_vendor()); } } // string uplink1_ifname = 100 [json_name = "uplink1Ifname"]; @@ -4638,877 +4727,901 @@ ::size_t XtcpFlatRecord::ByteSizeLong() const { this_._internal_uplink2_lldp_port_descr()); } } - // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; + // string enrich_socket_interface_name = 300 [json_name = "enrichSocketInterfaceName"]; if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (!this_._internal_inet_diag_msg_socket_source().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( - this_._internal_inet_diag_msg_socket_source()); + if (!this_._internal_enrich_socket_interface_name().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_enrich_socket_interface_name()); } } - // bytes inet_diag_msg_socket_destination = 1008 [json_name = "inetDiagMsgSocketDestination"]; + // string enrich_socket_dest_egress_ifname = 312 [json_name = "enrichSocketDestEgressIfname"]; if (CheckHasBit(cached_has_bits, 0x00000080U)) { - if (!this_._internal_inet_diag_msg_socket_destination().empty()) { - total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( - this_._internal_inet_diag_msg_socket_destination()); + if (!this_._internal_enrich_socket_dest_egress_ifname().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_enrich_socket_dest_egress_ifname()); } } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; + // string enrich_socket_dest_network_owner = 322 [json_name = "enrichSocketDestNetworkOwner"]; if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (!this_._internal_inet_diag_msg_socket_dest_network_owner().empty()) { + if (!this_._internal_enrich_socket_dest_network_owner().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_inet_diag_msg_socket_dest_network_owner()); + this_._internal_enrich_socket_dest_network_owner()); } } - // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; + // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (!this_._internal_congestion_algorithm_string().empty()) { + if (!this_._internal_inet_diag_msg_socket_source().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_inet_diag_msg_socket_source()); + } + } + // bytes inet_diag_msg_socket_destination = 1008 [json_name = "inetDiagMsgSocketDestination"]; + if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (!this_._internal_inet_diag_msg_socket_destination().empty()) { + total_size += 2 + ::google::protobuf::internal::WireFormatLite::BytesSize( + this_._internal_inet_diag_msg_socket_destination()); + } + } + // string inet_diag_cong = 1300 [json_name = "inetDiagCong"]; + if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (!this_._internal_inet_diag_cong().empty()) { total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_congestion_algorithm_string()); + this_._internal_inet_diag_cong()); } } // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_netlinker_id() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_netlinker_id()); } } // uint32 uplink1_nic_pci_device = 104 [json_name = "uplink1NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_uplink1_nic_pci_device() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink1_nic_pci_device()); } } // uint32 uplink1_nic_speed_mbps = 106 [json_name = "uplink1NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_uplink1_nic_speed_mbps() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink1_nic_speed_mbps()); } } // uint32 uplink2_nic_pci_vendor = 203 [json_name = "uplink2NicPciVendor"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_uplink2_nic_pci_vendor() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_pci_vendor()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 uplink2_nic_pci_device = 204 [json_name = "uplink2NicPciDevice"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_uplink2_nic_pci_device() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_pci_device()); } } // uint32 uplink2_nic_speed_mbps = 206 [json_name = "uplink2NicSpeedMbps"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_uplink2_nic_speed_mbps() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_uplink2_nic_speed_mbps()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality enrich_socket_dest_locality = 310 [json_name = "enrichSocketDestLocality"]; + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (this_._internal_enrich_socket_dest_locality() != 0) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_enrich_socket_dest_locality()); + } + } + // uint64 enrich_socket_dest_asn = 320 [json_name = "enrichSocketDestAsn"]; + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (this_._internal_enrich_socket_dest_asn() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_enrich_socket_dest_asn()); + } + } + // uint32 enrich_socket_dest_egress_ifindex = 311 [json_name = "enrichSocketDestEgressIfindex"]; + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (this_._internal_enrich_socket_dest_egress_ifindex() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_enrich_socket_dest_egress_ifindex()); + } + } // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_inet_diag_msg_family() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_family()); } } // uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_inet_diag_msg_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_state()); } } // uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_inet_diag_msg_timer() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_timer()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_inet_diag_msg_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_retrans()); } } // uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_inet_diag_msg_socket_source_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_socket_source_port()); } } // uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_inet_diag_msg_socket_destination_port() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_socket_destination_port()); } } - // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (this_._internal_inet_diag_msg_expires() != 0) { + // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; + if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (this_._internal_inet_diag_msg_socket_interface() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_inet_diag_msg_expires()); + this_._internal_inet_diag_msg_socket_interface()); } } // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_inet_diag_msg_socket_cookie() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_inet_diag_msg_socket_cookie()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (this_._internal_inet_diag_msg_socket_dest_asn() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_inet_diag_msg_socket_dest_asn()); - } - } - // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (this_._internal_inet_diag_msg_socket_next_hop_asn() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_inet_diag_msg_socket_next_hop_asn()); + // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; + if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (this_._internal_inet_diag_msg_expires() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal_inet_diag_msg_expires()); } } // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_inet_diag_msg_rqueue() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_rqueue()); } } // uint32 inet_diag_msg_wqueue = 1015 [json_name = "inetDiagMsgWqueue"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_inet_diag_msg_wqueue() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_wqueue()); } } + } + cached_has_bits = this_._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 inet_diag_msg_uid = 1016 [json_name = "inetDiagMsgUid"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_inet_diag_msg_uid() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_uid()); } } // uint32 inet_diag_msg_inode = 1017 [json_name = "inetDiagMsgInode"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_inet_diag_msg_inode() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_inet_diag_msg_inode()); } } - // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (this_._internal_inet_diag_msg_socket_dest_locality() != 0) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_inet_diag_msg_socket_dest_locality()); - } - } // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_mem_info_rmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_rmem()); } } - } - cached_has_bits = this_._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 mem_info_wmem = 1102 [json_name = "memInfoWmem"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (this_._internal_mem_info_wmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_wmem()); } } // uint32 mem_info_fmem = 1103 [json_name = "memInfoFmem"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_mem_info_fmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_fmem()); } } // uint32 mem_info_tmem = 1104 [json_name = "memInfoTmem"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_mem_info_tmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_mem_info_tmem()); } } // uint32 tcp_info_state = 1201 [json_name = "tcpInfoState"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_state()); } } // uint32 tcp_info_ca_state = 1202 [json_name = "tcpInfoCaState"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_ca_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ca_state()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_retransmits = 1203 [json_name = "tcpInfoRetransmits"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_retransmits() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retransmits()); } } // uint32 tcp_info_probes = 1204 [json_name = "tcpInfoProbes"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_probes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_probes()); } } // uint32 tcp_info_backoff = 1205 [json_name = "tcpInfoBackoff"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_backoff() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_backoff()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 tcp_info_options = 1206 [json_name = "tcpInfoOptions"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_options() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_options()); } } - // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (this_._internal_tcp_info_send_scale() != 0) { + // uint32 tcp_info_snd_wscale = 1207 [json_name = "tcpInfoSndWscale"]; + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (this_._internal_tcp_info_snd_wscale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_send_scale()); + this_._internal_tcp_info_snd_wscale()); } } - // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (this_._internal_tcp_info_rcv_scale() != 0) { + // uint32 tcp_info_rcv_wscale = 1208 [json_name = "tcpInfoRcvWscale"]; + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (this_._internal_tcp_info_rcv_wscale() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_rcv_scale()); + this_._internal_tcp_info_rcv_wscale()); } } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_tcp_info_delivery_rate_app_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivery_rate_app_limited()); } } - // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (this_._internal_tcp_info_fast_open_client_failed() != 0) { + // uint32 tcp_info_fastopen_client_fail = 1210 [json_name = "tcpInfoFastopenClientFail"]; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (this_._internal_tcp_info_fastopen_client_fail() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_fast_open_client_failed()); + this_._internal_tcp_info_fastopen_client_fail()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rto()); } } // uint32 tcp_info_ato = 1216 [json_name = "tcpInfoAto"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_ato() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_ato()); } } // uint32 tcp_info_snd_mss = 1217 [json_name = "tcpInfoSndMss"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_snd_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_mss()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_rcv_mss = 1218 [json_name = "tcpInfoRcvMss"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_rcv_mss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_mss()); } } // uint32 tcp_info_unacked = 1219 [json_name = "tcpInfoUnacked"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_unacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_unacked()); } } // uint32 tcp_info_sacked = 1220 [json_name = "tcpInfoSacked"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_sacked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_sacked()); } } // uint32 tcp_info_lost = 1221 [json_name = "tcpInfoLost"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_lost() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_lost()); } } // uint32 tcp_info_retrans = 1222 [json_name = "tcpInfoRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_retrans()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_fackets = 1223 [json_name = "tcpInfoFackets"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_fackets() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_fackets()); } } // uint32 tcp_info_last_data_sent = 1224 [json_name = "tcpInfoLastDataSent"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_last_data_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_sent()); } } // uint32 tcp_info_last_ack_sent = 1225 [json_name = "tcpInfoLastAckSent"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_last_ack_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_sent()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_last_data_recv = 1226 [json_name = "tcpInfoLastDataRecv"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_last_data_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_data_recv()); } } // uint32 tcp_info_last_ack_recv = 1227 [json_name = "tcpInfoLastAckRecv"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_last_ack_recv() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_last_ack_recv()); } } // uint32 tcp_info_pmtu = 1228 [json_name = "tcpInfoPmtu"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_pmtu() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_pmtu()); } } // uint32 tcp_info_rcv_ssthresh = 1229 [json_name = "tcpInfoRcvSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_rcv_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ssthresh()); } } // uint32 tcp_info_rtt = 1230 [json_name = "tcpInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rtt()); } } - // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_tcp_info_rtt_var() != 0) { + } + cached_has_bits = this_._impl_._has_bits_[3]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { + // uint32 tcp_info_rttvar = 1231 [json_name = "tcpInfoRttvar"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (this_._internal_tcp_info_rttvar() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_rtt_var()); + this_._internal_tcp_info_rttvar()); } } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_snd_ssthresh() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_ssthresh()); } } // uint32 tcp_info_snd_cwnd = 1233 [json_name = "tcpInfoSndCwnd"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_snd_cwnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_cwnd()); } } - } - cached_has_bits = this_._impl_._has_bits_[3]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (this_._internal_tcp_info_adv_mss() != 0) { + // uint32 tcp_info_advmss = 1234 [json_name = "tcpInfoAdvmss"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_tcp_info_advmss() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_adv_mss()); + this_._internal_tcp_info_advmss()); } } // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (this_._internal_tcp_info_reordering() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reordering()); } } // uint32 tcp_info_rcv_rtt = 1236 [json_name = "tcpInfoRcvRtt"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (this_._internal_tcp_info_rcv_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_rtt()); } } // uint32 tcp_info_rcv_space = 1237 [json_name = "tcpInfoRcvSpace"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_tcp_info_rcv_space() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_space()); } } // uint64 tcp_info_pacing_rate = 1239 [json_name = "tcpInfoPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (this_._internal_tcp_info_pacing_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_pacing_rate()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint64 tcp_info_max_pacing_rate = 1240 [json_name = "tcpInfoMaxPacingRate"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_tcp_info_max_pacing_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_max_pacing_rate()); } } // uint32 tcp_info_total_retrans = 1238 [json_name = "tcpInfoTotalRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (this_._internal_tcp_info_total_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_retrans()); } } // uint32 tcp_info_segs_out = 1243 [json_name = "tcpInfoSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_tcp_info_segs_out() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_segs_out()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint64 tcp_info_bytes_acked = 1241 [json_name = "tcpInfoBytesAcked"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_tcp_info_bytes_acked() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_acked()); } } // uint64 tcp_info_bytes_received = 1242 [json_name = "tcpInfoBytesReceived"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_tcp_info_bytes_received() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_received()); } } // uint32 tcp_info_segs_in = 1244 [json_name = "tcpInfoSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_tcp_info_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_segs_in()); } } - // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (this_._internal_tcp_info_not_sent_bytes() != 0) { + // uint32 tcp_info_notsent_bytes = 1245 [json_name = "tcpInfoNotsentBytes"]; + if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (this_._internal_tcp_info_notsent_bytes() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_tcp_info_not_sent_bytes()); + this_._internal_tcp_info_notsent_bytes()); } } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (this_._internal_tcp_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_min_rtt()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_data_segs_in = 1247 [json_name = "tcpInfoDataSegsIn"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_tcp_info_data_segs_in() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_data_segs_in()); } } // uint64 tcp_info_delivery_rate = 1249 [json_name = "tcpInfoDeliveryRate"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (this_._internal_tcp_info_delivery_rate() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_delivery_rate()); } } // uint64 tcp_info_busy_time = 1250 [json_name = "tcpInfoBusyTime"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_tcp_info_busy_time() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_busy_time()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 tcp_info_data_segs_out = 1248 [json_name = "tcpInfoDataSegsOut"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (this_._internal_tcp_info_data_segs_out() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_data_segs_out()); } } // uint32 tcp_info_delivered = 1253 [json_name = "tcpInfoDelivered"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_tcp_info_delivered() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivered()); } } // uint64 tcp_info_rwnd_limited = 1251 [json_name = "tcpInfoRwndLimited"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_tcp_info_rwnd_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_rwnd_limited()); } } // uint64 tcp_info_sndbuf_limited = 1252 [json_name = "tcpInfoSndbufLimited"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_tcp_info_sndbuf_limited() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_sndbuf_limited()); } } // uint64 tcp_info_bytes_sent = 1255 [json_name = "tcpInfoBytesSent"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_tcp_info_bytes_sent() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_sent()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_delivered_ce = 1254 [json_name = "tcpInfoDeliveredCe"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_tcp_info_delivered_ce() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_delivered_ce()); } } // uint32 tcp_info_dsack_dups = 1257 [json_name = "tcpInfoDsackDups"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_tcp_info_dsack_dups() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_dsack_dups()); } } // uint64 tcp_info_bytes_retrans = 1256 [json_name = "tcpInfoBytesRetrans"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_tcp_info_bytes_retrans() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( this_._internal_tcp_info_bytes_retrans()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 tcp_info_reord_seen = 1258 [json_name = "tcpInfoReordSeen"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_tcp_info_reord_seen() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_reord_seen()); } } // uint32 tcp_info_rcv_ooopack = 1259 [json_name = "tcpInfoRcvOoopack"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_tcp_info_rcv_ooopack() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_ooopack()); } } // uint32 tcp_info_snd_wnd = 1260 [json_name = "tcpInfoSndWnd"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_tcp_info_snd_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_snd_wnd()); } } // uint32 tcp_info_rcv_wnd = 1261 [json_name = "tcpInfoRcvWnd"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (this_._internal_tcp_info_rcv_wnd() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rcv_wnd()); } } // uint32 tcp_info_rehash = 1262 [json_name = "tcpInfoRehash"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (this_._internal_tcp_info_rehash() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_rehash()); } } + } + cached_has_bits = this_._impl_._has_bits_[4]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { // uint32 tcp_info_total_rto = 1263 [json_name = "tcpInfoTotalRto"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (this_._internal_tcp_info_total_rto() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto()); } } // uint32 tcp_info_total_rto_recoveries = 1264 [json_name = "tcpInfoTotalRtoRecoveries"]; - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (this_._internal_tcp_info_total_rto_recoveries() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_recoveries()); } } // uint32 tcp_info_total_rto_time = 1265 [json_name = "tcpInfoTotalRtoTime"]; - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (this_._internal_tcp_info_total_rto_time() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_tcp_info_total_rto_time()); } } - } - cached_has_bits = this_._impl_._has_bits_[4]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (this_._internal_congestion_algorithm_enum() != 0) { + // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm inet_diag_cong_enum = 1301 [json_name = "inetDiagCongEnum"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_inet_diag_cong_enum() != 0) { total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_congestion_algorithm_enum()); + ::_pbi::WireFormatLite::EnumSize(this_._internal_inet_diag_cong_enum()); } } - // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_type_of_service() != 0) { + // uint32 inet_diag_tos = 1401 [json_name = "inetDiagTos"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_inet_diag_tos() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_type_of_service()); + this_._internal_inet_diag_tos()); } } - // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_traffic_class() != 0) { + // uint32 inet_diag_tclass = 1402 [json_name = "inetDiagTclass"]; + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (this_._internal_inet_diag_tclass() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_traffic_class()); + this_._internal_inet_diag_tclass()); } } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (this_._internal_sk_mem_info_rmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_rmem_alloc()); } } - // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (this_._internal_sk_mem_info_rcv_buf() != 0) { + // uint32 sk_mem_info_rcvbuf = 1502 [json_name = "skMemInfoRcvbuf"]; + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (this_._internal_sk_mem_info_rcvbuf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_sk_mem_info_rcv_buf()); + this_._internal_sk_mem_info_rcvbuf()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (this_._internal_sk_mem_info_wmem_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_alloc()); } } - // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (this_._internal_sk_mem_info_snd_buf() != 0) { + // uint32 sk_mem_info_sndbuf = 1504 [json_name = "skMemInfoSndbuf"]; + if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (this_._internal_sk_mem_info_sndbuf() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_sk_mem_info_snd_buf()); + this_._internal_sk_mem_info_sndbuf()); } } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (this_._internal_sk_mem_info_fwd_alloc() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_fwd_alloc()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { // uint32 sk_mem_info_wmem_queued = 1506 [json_name = "skMemInfoWmemQueued"]; - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (this_._internal_sk_mem_info_wmem_queued() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_wmem_queued()); } } // uint32 sk_mem_info_optmem = 1507 [json_name = "skMemInfoOptmem"]; - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (this_._internal_sk_mem_info_optmem() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_optmem()); } } // uint32 sk_mem_info_backlog = 1508 [json_name = "skMemInfoBacklog"]; - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (this_._internal_sk_mem_info_backlog() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_backlog()); } } // uint32 sk_mem_info_drops = 1509 [json_name = "skMemInfoDrops"]; - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (this_._internal_sk_mem_info_drops() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_sk_mem_info_drops()); } } - // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (this_._internal_shutdown_state() != 0) { + // uint32 inet_diag_shutdown = 1600 [json_name = "inetDiagShutdown"]; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (this_._internal_inet_diag_shutdown() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_shutdown_state()); + this_._internal_inet_diag_shutdown()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (this_._internal_vegas_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_enabled()); } } - // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (this_._internal_vegas_info_rtt_cnt() != 0) { + // uint32 vegas_info_rttcnt = 1702 [json_name = "vegasInfoRttcnt"]; + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (this_._internal_vegas_info_rttcnt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_vegas_info_rtt_cnt()); + this_._internal_vegas_info_rttcnt()); } } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (this_._internal_vegas_info_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_vegas_info_rtt()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (this_._internal_vegas_info_min_rtt() != 0) { + // uint32 vegas_info_minrtt = 1704 [json_name = "vegasInfoMinrtt"]; + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (this_._internal_vegas_info_minrtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_vegas_info_min_rtt()); + this_._internal_vegas_info_minrtt()); } } // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (this_._internal_dctcp_info_enabled() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_enabled()); } } // uint32 dctcp_info_ce_state = 1802 [json_name = "dctcpInfoCeState"]; - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (this_._internal_dctcp_info_ce_state() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ce_state()); } } // uint32 dctcp_info_alpha = 1803 [json_name = "dctcpInfoAlpha"]; - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (this_._internal_dctcp_info_alpha() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_alpha()); } } // uint32 dctcp_info_ab_ecn = 1804 [json_name = "dctcpInfoAbEcn"]; - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (this_._internal_dctcp_info_ab_ecn() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_ecn()); } } + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { // uint32 dctcp_info_ab_tot = 1805 [json_name = "dctcpInfoAbTot"]; - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (this_._internal_dctcp_info_ab_tot() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_dctcp_info_ab_tot()); } } // uint32 bbr_info_bw_lo = 1901 [json_name = "bbrInfoBwLo"]; - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (this_._internal_bbr_info_bw_lo() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_lo()); } } // uint32 bbr_info_bw_hi = 1902 [json_name = "bbrInfoBwHi"]; - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (this_._internal_bbr_info_bw_hi() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_bw_hi()); } } - } - if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { // uint32 bbr_info_min_rtt = 1903 [json_name = "bbrInfoMinRtt"]; - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (this_._internal_bbr_info_min_rtt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_min_rtt()); } } // uint32 bbr_info_pacing_gain = 1904 [json_name = "bbrInfoPacingGain"]; - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (this_._internal_bbr_info_pacing_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_pacing_gain()); } } // uint32 bbr_info_cwnd_gain = 1905 [json_name = "bbrInfoCwndGain"]; - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (this_._internal_bbr_info_cwnd_gain() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( this_._internal_bbr_info_cwnd_gain()); } } - // uint32 class_id = 2001 [json_name = "classId"]; - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (this_._internal_class_id() != 0) { + // uint32 inet_diag_class_id = 2001 [json_name = "inetDiagClassId"]; + if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (this_._internal_inet_diag_class_id() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_class_id()); + this_._internal_inet_diag_class_id()); } } - // uint64 c_group = 2103 [json_name = "cGroup"]; - if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (this_._internal_c_group() != 0) { - total_size += 3 + ::_pbi::WireFormatLite::UInt64Size( - this_._internal_c_group()); + // uint64 inet_diag_cgroup_id = 2003 [json_name = "inetDiagCgroupId"]; + if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (this_._internal_inet_diag_cgroup_id() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt64Size( + this_._internal_inet_diag_cgroup_id()); } } - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (this_._internal_sock_opt() != 0) { + } + { + // uint32 inet_diag_sockopt = 2002 [json_name = "inetDiagSockopt"]; + cached_has_bits = this_._impl_._has_bits_[5]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (this_._internal_inet_diag_sockopt() != 0) { total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal_sock_opt()); + this_._internal_inet_diag_sockopt()); } } } @@ -5664,13 +5777,13 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00020000U)) { - if (from._internal_uplink1_nic_pci_vendor() != 0) { - _this->_impl_.uplink1_nic_pci_vendor_ = from._impl_.uplink1_nic_pci_vendor_; + if (from._internal_enrich_socket_dest_next_hop_asn() != 0) { + _this->_impl_.enrich_socket_dest_next_hop_asn_ = from._impl_.enrich_socket_dest_next_hop_asn_; } } if (CheckHasBit(cached_has_bits, 0x00040000U)) { - if (from._internal_inet_diag_msg_socket_interface() != 0) { - _this->_impl_.inet_diag_msg_socket_interface_ = from._impl_.inet_diag_msg_socket_interface_; + if (from._internal_uplink1_nic_pci_vendor() != 0) { + _this->_impl_.uplink1_nic_pci_vendor_ = from._impl_.uplink1_nic_pci_vendor_; } } if (CheckHasBit(cached_has_bits, 0x00080000U)) { @@ -5850,653 +5963,677 @@ void XtcpFlatRecord::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (!from._internal_inet_diag_msg_socket_source().empty()) { - _this->_internal_set_inet_diag_msg_socket_source(from._internal_inet_diag_msg_socket_source()); + if (!from._internal_enrich_socket_interface_name().empty()) { + _this->_internal_set_enrich_socket_interface_name(from._internal_enrich_socket_interface_name()); } else { - if (_this->_impl_.inet_diag_msg_socket_source_.IsDefault()) { - _this->_internal_set_inet_diag_msg_socket_source(""); + if (_this->_impl_.enrich_socket_interface_name_.IsDefault()) { + _this->_internal_set_enrich_socket_interface_name(""); } } } if (CheckHasBit(cached_has_bits, 0x00000080U)) { - if (!from._internal_inet_diag_msg_socket_destination().empty()) { - _this->_internal_set_inet_diag_msg_socket_destination(from._internal_inet_diag_msg_socket_destination()); + if (!from._internal_enrich_socket_dest_egress_ifname().empty()) { + _this->_internal_set_enrich_socket_dest_egress_ifname(from._internal_enrich_socket_dest_egress_ifname()); } else { - if (_this->_impl_.inet_diag_msg_socket_destination_.IsDefault()) { - _this->_internal_set_inet_diag_msg_socket_destination(""); + if (_this->_impl_.enrich_socket_dest_egress_ifname_.IsDefault()) { + _this->_internal_set_enrich_socket_dest_egress_ifname(""); } } } } if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { if (CheckHasBit(cached_has_bits, 0x00000100U)) { - if (!from._internal_inet_diag_msg_socket_dest_network_owner().empty()) { - _this->_internal_set_inet_diag_msg_socket_dest_network_owner(from._internal_inet_diag_msg_socket_dest_network_owner()); + if (!from._internal_enrich_socket_dest_network_owner().empty()) { + _this->_internal_set_enrich_socket_dest_network_owner(from._internal_enrich_socket_dest_network_owner()); } else { - if (_this->_impl_.inet_diag_msg_socket_dest_network_owner_.IsDefault()) { - _this->_internal_set_inet_diag_msg_socket_dest_network_owner(""); + if (_this->_impl_.enrich_socket_dest_network_owner_.IsDefault()) { + _this->_internal_set_enrich_socket_dest_network_owner(""); } } } if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (!from._internal_congestion_algorithm_string().empty()) { - _this->_internal_set_congestion_algorithm_string(from._internal_congestion_algorithm_string()); + if (!from._internal_inet_diag_msg_socket_source().empty()) { + _this->_internal_set_inet_diag_msg_socket_source(from._internal_inet_diag_msg_socket_source()); } else { - if (_this->_impl_.congestion_algorithm_string_.IsDefault()) { - _this->_internal_set_congestion_algorithm_string(""); + if (_this->_impl_.inet_diag_msg_socket_source_.IsDefault()) { + _this->_internal_set_inet_diag_msg_socket_source(""); } } } if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (from._internal_netlinker_id() != 0) { - _this->_impl_.netlinker_id_ = from._impl_.netlinker_id_; + if (!from._internal_inet_diag_msg_socket_destination().empty()) { + _this->_internal_set_inet_diag_msg_socket_destination(from._internal_inet_diag_msg_socket_destination()); + } else { + if (_this->_impl_.inet_diag_msg_socket_destination_.IsDefault()) { + _this->_internal_set_inet_diag_msg_socket_destination(""); + } } } if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (from._internal_uplink1_nic_pci_device() != 0) { - _this->_impl_.uplink1_nic_pci_device_ = from._impl_.uplink1_nic_pci_device_; + if (!from._internal_inet_diag_cong().empty()) { + _this->_internal_set_inet_diag_cong(from._internal_inet_diag_cong()); + } else { + if (_this->_impl_.inet_diag_cong_.IsDefault()) { + _this->_internal_set_inet_diag_cong(""); + } } } if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (from._internal_netlinker_id() != 0) { + _this->_impl_.netlinker_id_ = from._impl_.netlinker_id_; + } + } + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (from._internal_uplink1_nic_pci_device() != 0) { + _this->_impl_.uplink1_nic_pci_device_ = from._impl_.uplink1_nic_pci_device_; + } + } + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_uplink1_nic_speed_mbps() != 0) { _this->_impl_.uplink1_nic_speed_mbps_ = from._impl_.uplink1_nic_speed_mbps_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_uplink2_nic_pci_vendor() != 0) { _this->_impl_.uplink2_nic_pci_vendor_ = from._impl_.uplink2_nic_pci_vendor_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_uplink2_nic_pci_device() != 0) { _this->_impl_.uplink2_nic_pci_device_ = from._impl_.uplink2_nic_pci_device_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_uplink2_nic_speed_mbps() != 0) { _this->_impl_.uplink2_nic_speed_mbps_ = from._impl_.uplink2_nic_speed_mbps_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (from._internal_enrich_socket_dest_locality() != 0) { + _this->_impl_.enrich_socket_dest_locality_ = from._impl_.enrich_socket_dest_locality_; + } + } + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (from._internal_enrich_socket_dest_asn() != 0) { + _this->_impl_.enrich_socket_dest_asn_ = from._impl_.enrich_socket_dest_asn_; + } + } + if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (from._internal_enrich_socket_dest_egress_ifindex() != 0) { + _this->_impl_.enrich_socket_dest_egress_ifindex_ = from._impl_.enrich_socket_dest_egress_ifindex_; + } + } + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_inet_diag_msg_family() != 0) { _this->_impl_.inet_diag_msg_family_ = from._impl_.inet_diag_msg_family_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_inet_diag_msg_state() != 0) { _this->_impl_.inet_diag_msg_state_ = from._impl_.inet_diag_msg_state_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_inet_diag_msg_timer() != 0) { _this->_impl_.inet_diag_msg_timer_ = from._impl_.inet_diag_msg_timer_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_inet_diag_msg_retrans() != 0) { _this->_impl_.inet_diag_msg_retrans_ = from._impl_.inet_diag_msg_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_inet_diag_msg_socket_source_port() != 0) { _this->_impl_.inet_diag_msg_socket_source_port_ = from._impl_.inet_diag_msg_socket_source_port_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_inet_diag_msg_socket_destination_port() != 0) { _this->_impl_.inet_diag_msg_socket_destination_port_ = from._impl_.inet_diag_msg_socket_destination_port_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { - if (from._internal_inet_diag_msg_expires() != 0) { - _this->_impl_.inet_diag_msg_expires_ = from._impl_.inet_diag_msg_expires_; + if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (from._internal_inet_diag_msg_socket_interface() != 0) { + _this->_impl_.inet_diag_msg_socket_interface_ = from._impl_.inet_diag_msg_socket_interface_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_inet_diag_msg_socket_cookie() != 0) { _this->_impl_.inet_diag_msg_socket_cookie_ = from._impl_.inet_diag_msg_socket_cookie_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { - if (from._internal_inet_diag_msg_socket_dest_asn() != 0) { - _this->_impl_.inet_diag_msg_socket_dest_asn_ = from._impl_.inet_diag_msg_socket_dest_asn_; - } - } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { - if (from._internal_inet_diag_msg_socket_next_hop_asn() != 0) { - _this->_impl_.inet_diag_msg_socket_next_hop_asn_ = from._impl_.inet_diag_msg_socket_next_hop_asn_; + if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (from._internal_inet_diag_msg_expires() != 0) { + _this->_impl_.inet_diag_msg_expires_ = from._impl_.inet_diag_msg_expires_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_inet_diag_msg_rqueue() != 0) { _this->_impl_.inet_diag_msg_rqueue_ = from._impl_.inet_diag_msg_rqueue_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_inet_diag_msg_wqueue() != 0) { _this->_impl_.inet_diag_msg_wqueue_ = from._impl_.inet_diag_msg_wqueue_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + } + cached_has_bits = from._impl_._has_bits_[2]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (from._internal_inet_diag_msg_uid() != 0) { _this->_impl_.inet_diag_msg_uid_ = from._impl_.inet_diag_msg_uid_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_inet_diag_msg_inode() != 0) { _this->_impl_.inet_diag_msg_inode_ = from._impl_.inet_diag_msg_inode_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { - if (from._internal_inet_diag_msg_socket_dest_locality() != 0) { - _this->_impl_.inet_diag_msg_socket_dest_locality_ = from._impl_.inet_diag_msg_socket_dest_locality_; - } - } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_mem_info_rmem() != 0) { _this->_impl_.mem_info_rmem_ = from._impl_.mem_info_rmem_; } } - } - cached_has_bits = from._impl_._has_bits_[2]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (CheckHasBit(cached_has_bits, 0x00000008U)) { if (from._internal_mem_info_wmem() != 0) { _this->_impl_.mem_info_wmem_ = from._impl_.mem_info_wmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_mem_info_fmem() != 0) { _this->_impl_.mem_info_fmem_ = from._impl_.mem_info_fmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_mem_info_tmem() != 0) { _this->_impl_.mem_info_tmem_ = from._impl_.mem_info_tmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_tcp_info_state() != 0) { _this->_impl_.tcp_info_state_ = from._impl_.tcp_info_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_tcp_info_ca_state() != 0) { _this->_impl_.tcp_info_ca_state_ = from._impl_.tcp_info_ca_state_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_tcp_info_retransmits() != 0) { _this->_impl_.tcp_info_retransmits_ = from._impl_.tcp_info_retransmits_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_tcp_info_probes() != 0) { _this->_impl_.tcp_info_probes_ = from._impl_.tcp_info_probes_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_backoff() != 0) { _this->_impl_.tcp_info_backoff_ = from._impl_.tcp_info_backoff_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_options() != 0) { _this->_impl_.tcp_info_options_ = from._impl_.tcp_info_options_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { - if (from._internal_tcp_info_send_scale() != 0) { - _this->_impl_.tcp_info_send_scale_ = from._impl_.tcp_info_send_scale_; + if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (from._internal_tcp_info_snd_wscale() != 0) { + _this->_impl_.tcp_info_snd_wscale_ = from._impl_.tcp_info_snd_wscale_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { - if (from._internal_tcp_info_rcv_scale() != 0) { - _this->_impl_.tcp_info_rcv_scale_ = from._impl_.tcp_info_rcv_scale_; + if (CheckHasBit(cached_has_bits, 0x00002000U)) { + if (from._internal_tcp_info_rcv_wscale() != 0) { + _this->_impl_.tcp_info_rcv_wscale_ = from._impl_.tcp_info_rcv_wscale_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_tcp_info_delivery_rate_app_limited() != 0) { _this->_impl_.tcp_info_delivery_rate_app_limited_ = from._impl_.tcp_info_delivery_rate_app_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (from._internal_tcp_info_fast_open_client_failed() != 0) { - _this->_impl_.tcp_info_fast_open_client_failed_ = from._impl_.tcp_info_fast_open_client_failed_; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (from._internal_tcp_info_fastopen_client_fail() != 0) { + _this->_impl_.tcp_info_fastopen_client_fail_ = from._impl_.tcp_info_fastopen_client_fail_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_tcp_info_rto() != 0) { _this->_impl_.tcp_info_rto_ = from._impl_.tcp_info_rto_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_tcp_info_ato() != 0) { _this->_impl_.tcp_info_ato_ = from._impl_.tcp_info_ato_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_tcp_info_snd_mss() != 0) { _this->_impl_.tcp_info_snd_mss_ = from._impl_.tcp_info_snd_mss_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_tcp_info_rcv_mss() != 0) { _this->_impl_.tcp_info_rcv_mss_ = from._impl_.tcp_info_rcv_mss_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_tcp_info_unacked() != 0) { _this->_impl_.tcp_info_unacked_ = from._impl_.tcp_info_unacked_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_tcp_info_sacked() != 0) { _this->_impl_.tcp_info_sacked_ = from._impl_.tcp_info_sacked_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_tcp_info_lost() != 0) { _this->_impl_.tcp_info_lost_ = from._impl_.tcp_info_lost_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_tcp_info_retrans() != 0) { _this->_impl_.tcp_info_retrans_ = from._impl_.tcp_info_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_tcp_info_fackets() != 0) { _this->_impl_.tcp_info_fackets_ = from._impl_.tcp_info_fackets_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_last_data_sent() != 0) { _this->_impl_.tcp_info_last_data_sent_ = from._impl_.tcp_info_last_data_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_last_ack_sent() != 0) { _this->_impl_.tcp_info_last_ack_sent_ = from._impl_.tcp_info_last_ack_sent_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_last_data_recv() != 0) { _this->_impl_.tcp_info_last_data_recv_ = from._impl_.tcp_info_last_data_recv_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_last_ack_recv() != 0) { _this->_impl_.tcp_info_last_ack_recv_ = from._impl_.tcp_info_last_ack_recv_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_pmtu() != 0) { _this->_impl_.tcp_info_pmtu_ = from._impl_.tcp_info_pmtu_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_rcv_ssthresh() != 0) { _this->_impl_.tcp_info_rcv_ssthresh_ = from._impl_.tcp_info_rcv_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_tcp_info_rtt() != 0) { _this->_impl_.tcp_info_rtt_ = from._impl_.tcp_info_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (from._internal_tcp_info_rtt_var() != 0) { - _this->_impl_.tcp_info_rtt_var_ = from._impl_.tcp_info_rtt_var_; + } + cached_has_bits = from._impl_._has_bits_[3]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_tcp_info_rttvar() != 0) { + _this->_impl_.tcp_info_rttvar_ = from._impl_.tcp_info_rttvar_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_tcp_info_snd_ssthresh() != 0) { _this->_impl_.tcp_info_snd_ssthresh_ = from._impl_.tcp_info_snd_ssthresh_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_tcp_info_snd_cwnd() != 0) { _this->_impl_.tcp_info_snd_cwnd_ = from._impl_.tcp_info_snd_cwnd_; } } - } - cached_has_bits = from._impl_._has_bits_[3]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (from._internal_tcp_info_adv_mss() != 0) { - _this->_impl_.tcp_info_adv_mss_ = from._impl_.tcp_info_adv_mss_; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (from._internal_tcp_info_advmss() != 0) { + _this->_impl_.tcp_info_advmss_ = from._impl_.tcp_info_advmss_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000010U)) { if (from._internal_tcp_info_reordering() != 0) { _this->_impl_.tcp_info_reordering_ = from._impl_.tcp_info_reordering_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (CheckHasBit(cached_has_bits, 0x00000020U)) { if (from._internal_tcp_info_rcv_rtt() != 0) { _this->_impl_.tcp_info_rcv_rtt_ = from._impl_.tcp_info_rcv_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_tcp_info_rcv_space() != 0) { _this->_impl_.tcp_info_rcv_space_ = from._impl_.tcp_info_rcv_space_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (CheckHasBit(cached_has_bits, 0x00000080U)) { if (from._internal_tcp_info_pacing_rate() != 0) { _this->_impl_.tcp_info_pacing_rate_ = from._impl_.tcp_info_pacing_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_tcp_info_max_pacing_rate() != 0) { _this->_impl_.tcp_info_max_pacing_rate_ = from._impl_.tcp_info_max_pacing_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { + if (CheckHasBit(cached_has_bits, 0x00000200U)) { if (from._internal_tcp_info_total_retrans() != 0) { _this->_impl_.tcp_info_total_retrans_ = from._impl_.tcp_info_total_retrans_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_tcp_info_segs_out() != 0) { _this->_impl_.tcp_info_segs_out_ = from._impl_.tcp_info_segs_out_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_tcp_info_bytes_acked() != 0) { _this->_impl_.tcp_info_bytes_acked_ = from._impl_.tcp_info_bytes_acked_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_tcp_info_bytes_received() != 0) { _this->_impl_.tcp_info_bytes_received_ = from._impl_.tcp_info_bytes_received_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_tcp_info_segs_in() != 0) { _this->_impl_.tcp_info_segs_in_ = from._impl_.tcp_info_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { - if (from._internal_tcp_info_not_sent_bytes() != 0) { - _this->_impl_.tcp_info_not_sent_bytes_ = from._impl_.tcp_info_not_sent_bytes_; + if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (from._internal_tcp_info_notsent_bytes() != 0) { + _this->_impl_.tcp_info_notsent_bytes_ = from._impl_.tcp_info_notsent_bytes_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { + if (CheckHasBit(cached_has_bits, 0x00008000U)) { if (from._internal_tcp_info_min_rtt() != 0) { _this->_impl_.tcp_info_min_rtt_ = from._impl_.tcp_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_tcp_info_data_segs_in() != 0) { _this->_impl_.tcp_info_data_segs_in_ = from._impl_.tcp_info_data_segs_in_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { + if (CheckHasBit(cached_has_bits, 0x00020000U)) { if (from._internal_tcp_info_delivery_rate() != 0) { _this->_impl_.tcp_info_delivery_rate_ = from._impl_.tcp_info_delivery_rate_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_tcp_info_busy_time() != 0) { _this->_impl_.tcp_info_busy_time_ = from._impl_.tcp_info_busy_time_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { + if (CheckHasBit(cached_has_bits, 0x00080000U)) { if (from._internal_tcp_info_data_segs_out() != 0) { _this->_impl_.tcp_info_data_segs_out_ = from._impl_.tcp_info_data_segs_out_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_tcp_info_delivered() != 0) { _this->_impl_.tcp_info_delivered_ = from._impl_.tcp_info_delivered_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_tcp_info_rwnd_limited() != 0) { _this->_impl_.tcp_info_rwnd_limited_ = from._impl_.tcp_info_rwnd_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_tcp_info_sndbuf_limited() != 0) { _this->_impl_.tcp_info_sndbuf_limited_ = from._impl_.tcp_info_sndbuf_limited_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_tcp_info_bytes_sent() != 0) { _this->_impl_.tcp_info_bytes_sent_ = from._impl_.tcp_info_bytes_sent_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_tcp_info_delivered_ce() != 0) { _this->_impl_.tcp_info_delivered_ce_ = from._impl_.tcp_info_delivered_ce_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_tcp_info_dsack_dups() != 0) { _this->_impl_.tcp_info_dsack_dups_ = from._impl_.tcp_info_dsack_dups_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_tcp_info_bytes_retrans() != 0) { _this->_impl_.tcp_info_bytes_retrans_ = from._impl_.tcp_info_bytes_retrans_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_tcp_info_reord_seen() != 0) { _this->_impl_.tcp_info_reord_seen_ = from._impl_.tcp_info_reord_seen_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_tcp_info_rcv_ooopack() != 0) { _this->_impl_.tcp_info_rcv_ooopack_ = from._impl_.tcp_info_rcv_ooopack_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_tcp_info_snd_wnd() != 0) { _this->_impl_.tcp_info_snd_wnd_ = from._impl_.tcp_info_snd_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { + if (CheckHasBit(cached_has_bits, 0x40000000U)) { if (from._internal_tcp_info_rcv_wnd() != 0) { _this->_impl_.tcp_info_rcv_wnd_ = from._impl_.tcp_info_rcv_wnd_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { + if (CheckHasBit(cached_has_bits, 0x80000000U)) { if (from._internal_tcp_info_rehash() != 0) { _this->_impl_.tcp_info_rehash_ = from._impl_.tcp_info_rehash_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { + } + cached_has_bits = from._impl_._has_bits_[4]; + if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (from._internal_tcp_info_total_rto() != 0) { _this->_impl_.tcp_info_total_rto_ = from._impl_.tcp_info_total_rto_; } } - if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000002U)) { if (from._internal_tcp_info_total_rto_recoveries() != 0) { _this->_impl_.tcp_info_total_rto_recoveries_ = from._impl_.tcp_info_total_rto_recoveries_; } } - if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { if (from._internal_tcp_info_total_rto_time() != 0) { _this->_impl_.tcp_info_total_rto_time_ = from._impl_.tcp_info_total_rto_time_; } } - } - cached_has_bits = from._impl_._has_bits_[4]; - if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (from._internal_congestion_algorithm_enum() != 0) { - _this->_impl_.congestion_algorithm_enum_ = from._impl_.congestion_algorithm_enum_; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (from._internal_inet_diag_cong_enum() != 0) { + _this->_impl_.inet_diag_cong_enum_ = from._impl_.inet_diag_cong_enum_; } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_type_of_service() != 0) { - _this->_impl_.type_of_service_ = from._impl_.type_of_service_; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (from._internal_inet_diag_tos() != 0) { + _this->_impl_.inet_diag_tos_ = from._impl_.inet_diag_tos_; } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (from._internal_traffic_class() != 0) { - _this->_impl_.traffic_class_ = from._impl_.traffic_class_; + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + if (from._internal_inet_diag_tclass() != 0) { + _this->_impl_.inet_diag_tclass_ = from._impl_.inet_diag_tclass_; } } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (CheckHasBit(cached_has_bits, 0x00000040U)) { if (from._internal_sk_mem_info_rmem_alloc() != 0) { _this->_impl_.sk_mem_info_rmem_alloc_ = from._impl_.sk_mem_info_rmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (from._internal_sk_mem_info_rcv_buf() != 0) { - _this->_impl_.sk_mem_info_rcv_buf_ = from._impl_.sk_mem_info_rcv_buf_; + if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (from._internal_sk_mem_info_rcvbuf() != 0) { + _this->_impl_.sk_mem_info_rcvbuf_ = from._impl_.sk_mem_info_rcvbuf_; } } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { + if (CheckHasBit(cached_has_bits, 0x00000100U)) { if (from._internal_sk_mem_info_wmem_alloc() != 0) { _this->_impl_.sk_mem_info_wmem_alloc_ = from._impl_.sk_mem_info_wmem_alloc_; } } - if (CheckHasBit(cached_has_bits, 0x00000040U)) { - if (from._internal_sk_mem_info_snd_buf() != 0) { - _this->_impl_.sk_mem_info_snd_buf_ = from._impl_.sk_mem_info_snd_buf_; + if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (from._internal_sk_mem_info_sndbuf() != 0) { + _this->_impl_.sk_mem_info_sndbuf_ = from._impl_.sk_mem_info_sndbuf_; } } - if (CheckHasBit(cached_has_bits, 0x00000080U)) { + if (CheckHasBit(cached_has_bits, 0x00000400U)) { if (from._internal_sk_mem_info_fwd_alloc() != 0) { _this->_impl_.sk_mem_info_fwd_alloc_ = from._impl_.sk_mem_info_fwd_alloc_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) { - if (CheckHasBit(cached_has_bits, 0x00000100U)) { + if (CheckHasBit(cached_has_bits, 0x00000800U)) { if (from._internal_sk_mem_info_wmem_queued() != 0) { _this->_impl_.sk_mem_info_wmem_queued_ = from._impl_.sk_mem_info_wmem_queued_; } } - if (CheckHasBit(cached_has_bits, 0x00000200U)) { + if (CheckHasBit(cached_has_bits, 0x00001000U)) { if (from._internal_sk_mem_info_optmem() != 0) { _this->_impl_.sk_mem_info_optmem_ = from._impl_.sk_mem_info_optmem_; } } - if (CheckHasBit(cached_has_bits, 0x00000400U)) { + if (CheckHasBit(cached_has_bits, 0x00002000U)) { if (from._internal_sk_mem_info_backlog() != 0) { _this->_impl_.sk_mem_info_backlog_ = from._impl_.sk_mem_info_backlog_; } } - if (CheckHasBit(cached_has_bits, 0x00000800U)) { + if (CheckHasBit(cached_has_bits, 0x00004000U)) { if (from._internal_sk_mem_info_drops() != 0) { _this->_impl_.sk_mem_info_drops_ = from._impl_.sk_mem_info_drops_; } } - if (CheckHasBit(cached_has_bits, 0x00001000U)) { - if (from._internal_shutdown_state() != 0) { - _this->_impl_.shutdown_state_ = from._impl_.shutdown_state_; + if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (from._internal_inet_diag_shutdown() != 0) { + _this->_impl_.inet_diag_shutdown_ = from._impl_.inet_diag_shutdown_; } } - if (CheckHasBit(cached_has_bits, 0x00002000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { + if (CheckHasBit(cached_has_bits, 0x00010000U)) { if (from._internal_vegas_info_enabled() != 0) { _this->_impl_.vegas_info_enabled_ = from._impl_.vegas_info_enabled_; } } - if (CheckHasBit(cached_has_bits, 0x00004000U)) { - if (from._internal_vegas_info_rtt_cnt() != 0) { - _this->_impl_.vegas_info_rtt_cnt_ = from._impl_.vegas_info_rtt_cnt_; + if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (from._internal_vegas_info_rttcnt() != 0) { + _this->_impl_.vegas_info_rttcnt_ = from._impl_.vegas_info_rttcnt_; } } - if (CheckHasBit(cached_has_bits, 0x00008000U)) { + if (CheckHasBit(cached_has_bits, 0x00040000U)) { if (from._internal_vegas_info_rtt() != 0) { _this->_impl_.vegas_info_rtt_ = from._impl_.vegas_info_rtt_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) { - if (CheckHasBit(cached_has_bits, 0x00010000U)) { - if (from._internal_vegas_info_min_rtt() != 0) { - _this->_impl_.vegas_info_min_rtt_ = from._impl_.vegas_info_min_rtt_; + if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (from._internal_vegas_info_minrtt() != 0) { + _this->_impl_.vegas_info_minrtt_ = from._impl_.vegas_info_minrtt_; } } - if (CheckHasBit(cached_has_bits, 0x00020000U)) { + if (CheckHasBit(cached_has_bits, 0x00100000U)) { if (from._internal_dctcp_info_enabled() != 0) { _this->_impl_.dctcp_info_enabled_ = from._impl_.dctcp_info_enabled_; } } - if (CheckHasBit(cached_has_bits, 0x00040000U)) { + if (CheckHasBit(cached_has_bits, 0x00200000U)) { if (from._internal_dctcp_info_ce_state() != 0) { _this->_impl_.dctcp_info_ce_state_ = from._impl_.dctcp_info_ce_state_; } } - if (CheckHasBit(cached_has_bits, 0x00080000U)) { + if (CheckHasBit(cached_has_bits, 0x00400000U)) { if (from._internal_dctcp_info_alpha() != 0) { _this->_impl_.dctcp_info_alpha_ = from._impl_.dctcp_info_alpha_; } } - if (CheckHasBit(cached_has_bits, 0x00100000U)) { + if (CheckHasBit(cached_has_bits, 0x00800000U)) { if (from._internal_dctcp_info_ab_ecn() != 0) { _this->_impl_.dctcp_info_ab_ecn_ = from._impl_.dctcp_info_ab_ecn_; } } - if (CheckHasBit(cached_has_bits, 0x00200000U)) { + } + if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) { + if (CheckHasBit(cached_has_bits, 0x01000000U)) { if (from._internal_dctcp_info_ab_tot() != 0) { _this->_impl_.dctcp_info_ab_tot_ = from._impl_.dctcp_info_ab_tot_; } } - if (CheckHasBit(cached_has_bits, 0x00400000U)) { + if (CheckHasBit(cached_has_bits, 0x02000000U)) { if (from._internal_bbr_info_bw_lo() != 0) { _this->_impl_.bbr_info_bw_lo_ = from._impl_.bbr_info_bw_lo_; } } - if (CheckHasBit(cached_has_bits, 0x00800000U)) { + if (CheckHasBit(cached_has_bits, 0x04000000U)) { if (from._internal_bbr_info_bw_hi() != 0) { _this->_impl_.bbr_info_bw_hi_ = from._impl_.bbr_info_bw_hi_; } } - } - if (BatchCheckHasBit(cached_has_bits, 0x3f000000U)) { - if (CheckHasBit(cached_has_bits, 0x01000000U)) { + if (CheckHasBit(cached_has_bits, 0x08000000U)) { if (from._internal_bbr_info_min_rtt() != 0) { _this->_impl_.bbr_info_min_rtt_ = from._impl_.bbr_info_min_rtt_; } } - if (CheckHasBit(cached_has_bits, 0x02000000U)) { + if (CheckHasBit(cached_has_bits, 0x10000000U)) { if (from._internal_bbr_info_pacing_gain() != 0) { _this->_impl_.bbr_info_pacing_gain_ = from._impl_.bbr_info_pacing_gain_; } } - if (CheckHasBit(cached_has_bits, 0x04000000U)) { + if (CheckHasBit(cached_has_bits, 0x20000000U)) { if (from._internal_bbr_info_cwnd_gain() != 0) { _this->_impl_.bbr_info_cwnd_gain_ = from._impl_.bbr_info_cwnd_gain_; } } - if (CheckHasBit(cached_has_bits, 0x08000000U)) { - if (from._internal_class_id() != 0) { - _this->_impl_.class_id_ = from._impl_.class_id_; + if (CheckHasBit(cached_has_bits, 0x40000000U)) { + if (from._internal_inet_diag_class_id() != 0) { + _this->_impl_.inet_diag_class_id_ = from._impl_.inet_diag_class_id_; } } - if (CheckHasBit(cached_has_bits, 0x10000000U)) { - if (from._internal_c_group() != 0) { - _this->_impl_.c_group_ = from._impl_.c_group_; + if (CheckHasBit(cached_has_bits, 0x80000000U)) { + if (from._internal_inet_diag_cgroup_id() != 0) { + _this->_impl_.inet_diag_cgroup_id_ = from._impl_.inet_diag_cgroup_id_; } } - if (CheckHasBit(cached_has_bits, 0x20000000U)) { - if (from._internal_sock_opt() != 0) { - _this->_impl_.sock_opt_ = from._impl_.sock_opt_; - } + } + cached_has_bits = from._impl_._has_bits_[5]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (from._internal_inet_diag_sockopt() != 0) { + _this->_impl_.inet_diag_sockopt_ = from._impl_.inet_diag_sockopt_; } } _this->_impl_._has_bits_.Or(from._impl_._has_bits_); @@ -6522,6 +6659,7 @@ void XtcpFlatRecord::InternalSwap(XtcpFlatRecord* PROTOBUF_RESTRICT PROTOBUF_NON swap(_impl_._has_bits_[2], other->_impl_._has_bits_[2]); swap(_impl_._has_bits_[3], other->_impl_._has_bits_[3]); swap(_impl_._has_bits_[4], other->_impl_._has_bits_[4]); + swap(_impl_._has_bits_[5], other->_impl_._has_bits_[5]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.daemon_version_, &other->_impl_.daemon_version_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.hostname_, &other->_impl_.hostname_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.location_, &other->_impl_.location_, arena); @@ -6534,8 +6672,8 @@ void XtcpFlatRecord::InternalSwap(XtcpFlatRecord* PROTOBUF_RESTRICT PROTOBUF_NON ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.tag_, &other->_impl_.tag_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uplink1_nic_model_, &other->_impl_.uplink1_nic_model_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_msg_socket_interface_) - + sizeof(XtcpFlatRecord::_impl_.inet_diag_msg_socket_interface_) + PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.uplink1_nic_pci_vendor_) + + sizeof(XtcpFlatRecord::_impl_.uplink1_nic_pci_vendor_) - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.timestamp_ns_)>( reinterpret_cast(&_impl_.timestamp_ns_), reinterpret_cast(&other->_impl_.timestamp_ns_)); @@ -6558,13 +6696,15 @@ void XtcpFlatRecord::InternalSwap(XtcpFlatRecord* PROTOBUF_RESTRICT PROTOBUF_NON ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uplink2_lldp_mgmt_ip_, &other->_impl_.uplink2_lldp_mgmt_ip_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uplink2_lldp_port_id_, &other->_impl_.uplink2_lldp_port_id_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.uplink2_lldp_port_descr_, &other->_impl_.uplink2_lldp_port_descr_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enrich_socket_interface_name_, &other->_impl_.enrich_socket_interface_name_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enrich_socket_dest_egress_ifname_, &other->_impl_.enrich_socket_dest_egress_ifname_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.enrich_socket_dest_network_owner_, &other->_impl_.enrich_socket_dest_network_owner_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_source_, &other->_impl_.inet_diag_msg_socket_source_, arena); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_destination_, &other->_impl_.inet_diag_msg_socket_destination_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_msg_socket_dest_network_owner_, &other->_impl_.inet_diag_msg_socket_dest_network_owner_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.congestion_algorithm_string_, &other->_impl_.congestion_algorithm_string_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.inet_diag_cong_, &other->_impl_.inet_diag_cong_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.sock_opt_) - + sizeof(XtcpFlatRecord::_impl_.sock_opt_) + PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.inet_diag_sockopt_) + + sizeof(XtcpFlatRecord::_impl_.inet_diag_sockopt_) - PROTOBUF_FIELD_OFFSET(XtcpFlatRecord, _impl_.netlinker_id_)>( reinterpret_cast(&_impl_.netlinker_id_), reinterpret_cast(&other->_impl_.netlinker_id_)); diff --git a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h index 880ae85..f71c85a 100644 --- a/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h +++ b/gen/cpp/xtcp_flat_record/v1/xtcp_flat_record.pb.h @@ -433,8 +433,8 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kNetnsInodeFieldNumber = 31, kRecordCounterFieldNumber = 60, kSocketFdFieldNumber = 61, + kEnrichSocketDestNextHopAsnFieldNumber = 321, kUplink1NicPciVendorFieldNumber = 103, - kInetDiagMsgSocketInterfaceFieldNumber = 1009, kUplink1IfnameFieldNumber = 100, kUplink1NicDriverFieldNumber = 101, kUplink1NicBusInfoFieldNumber = 105, @@ -454,31 +454,34 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kUplink2LldpMgmtIpFieldNumber = 222, kUplink2LldpPortIdFieldNumber = 223, kUplink2LldpPortDescrFieldNumber = 224, + kEnrichSocketInterfaceNameFieldNumber = 300, + kEnrichSocketDestEgressIfnameFieldNumber = 312, + kEnrichSocketDestNetworkOwnerFieldNumber = 322, kInetDiagMsgSocketSourceFieldNumber = 1007, kInetDiagMsgSocketDestinationFieldNumber = 1008, - kInetDiagMsgSocketDestNetworkOwnerFieldNumber = 1018, - kCongestionAlgorithmStringFieldNumber = 1300, + kInetDiagCongFieldNumber = 1300, kNetlinkerIdFieldNumber = 62, kUplink1NicPciDeviceFieldNumber = 104, kUplink1NicSpeedMbpsFieldNumber = 106, kUplink2NicPciVendorFieldNumber = 203, kUplink2NicPciDeviceFieldNumber = 204, kUplink2NicSpeedMbpsFieldNumber = 206, + kEnrichSocketDestLocalityFieldNumber = 310, + kEnrichSocketDestAsnFieldNumber = 320, + kEnrichSocketDestEgressIfindexFieldNumber = 311, kInetDiagMsgFamilyFieldNumber = 1001, kInetDiagMsgStateFieldNumber = 1002, kInetDiagMsgTimerFieldNumber = 1003, kInetDiagMsgRetransFieldNumber = 1004, kInetDiagMsgSocketSourcePortFieldNumber = 1005, kInetDiagMsgSocketDestinationPortFieldNumber = 1006, - kInetDiagMsgExpiresFieldNumber = 1013, + kInetDiagMsgSocketInterfaceFieldNumber = 1009, kInetDiagMsgSocketCookieFieldNumber = 1010, - kInetDiagMsgSocketDestAsnFieldNumber = 1011, - kInetDiagMsgSocketNextHopAsnFieldNumber = 1012, + kInetDiagMsgExpiresFieldNumber = 1013, kInetDiagMsgRqueueFieldNumber = 1014, kInetDiagMsgWqueueFieldNumber = 1015, kInetDiagMsgUidFieldNumber = 1016, kInetDiagMsgInodeFieldNumber = 1017, - kInetDiagMsgSocketDestLocalityFieldNumber = 1019, kMemInfoRmemFieldNumber = 1101, kMemInfoWmemFieldNumber = 1102, kMemInfoFmemFieldNumber = 1103, @@ -489,10 +492,10 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kTcpInfoProbesFieldNumber = 1204, kTcpInfoBackoffFieldNumber = 1205, kTcpInfoOptionsFieldNumber = 1206, - kTcpInfoSendScaleFieldNumber = 1207, - kTcpInfoRcvScaleFieldNumber = 1208, + kTcpInfoSndWscaleFieldNumber = 1207, + kTcpInfoRcvWscaleFieldNumber = 1208, kTcpInfoDeliveryRateAppLimitedFieldNumber = 1209, - kTcpInfoFastOpenClientFailedFieldNumber = 1210, + kTcpInfoFastopenClientFailFieldNumber = 1210, kTcpInfoRtoFieldNumber = 1215, kTcpInfoAtoFieldNumber = 1216, kTcpInfoSndMssFieldNumber = 1217, @@ -509,10 +512,10 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kTcpInfoPmtuFieldNumber = 1228, kTcpInfoRcvSsthreshFieldNumber = 1229, kTcpInfoRttFieldNumber = 1230, - kTcpInfoRttVarFieldNumber = 1231, + kTcpInfoRttvarFieldNumber = 1231, kTcpInfoSndSsthreshFieldNumber = 1232, kTcpInfoSndCwndFieldNumber = 1233, - kTcpInfoAdvMssFieldNumber = 1234, + kTcpInfoAdvmssFieldNumber = 1234, kTcpInfoReorderingFieldNumber = 1235, kTcpInfoRcvRttFieldNumber = 1236, kTcpInfoRcvSpaceFieldNumber = 1237, @@ -523,7 +526,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kTcpInfoBytesAckedFieldNumber = 1241, kTcpInfoBytesReceivedFieldNumber = 1242, kTcpInfoSegsInFieldNumber = 1244, - kTcpInfoNotSentBytesFieldNumber = 1245, + kTcpInfoNotsentBytesFieldNumber = 1245, kTcpInfoMinRttFieldNumber = 1246, kTcpInfoDataSegsInFieldNumber = 1247, kTcpInfoDeliveryRateFieldNumber = 1249, @@ -544,23 +547,23 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kTcpInfoTotalRtoFieldNumber = 1263, kTcpInfoTotalRtoRecoveriesFieldNumber = 1264, kTcpInfoTotalRtoTimeFieldNumber = 1265, - kCongestionAlgorithmEnumFieldNumber = 1301, - kTypeOfServiceFieldNumber = 1401, - kTrafficClassFieldNumber = 1402, + kInetDiagCongEnumFieldNumber = 1301, + kInetDiagTosFieldNumber = 1401, + kInetDiagTclassFieldNumber = 1402, kSkMemInfoRmemAllocFieldNumber = 1501, - kSkMemInfoRcvBufFieldNumber = 1502, + kSkMemInfoRcvbufFieldNumber = 1502, kSkMemInfoWmemAllocFieldNumber = 1503, - kSkMemInfoSndBufFieldNumber = 1504, + kSkMemInfoSndbufFieldNumber = 1504, kSkMemInfoFwdAllocFieldNumber = 1505, kSkMemInfoWmemQueuedFieldNumber = 1506, kSkMemInfoOptmemFieldNumber = 1507, kSkMemInfoBacklogFieldNumber = 1508, kSkMemInfoDropsFieldNumber = 1509, - kShutdownStateFieldNumber = 1600, + kInetDiagShutdownFieldNumber = 1600, kVegasInfoEnabledFieldNumber = 1701, - kVegasInfoRttCntFieldNumber = 1702, + kVegasInfoRttcntFieldNumber = 1702, kVegasInfoRttFieldNumber = 1703, - kVegasInfoMinRttFieldNumber = 1704, + kVegasInfoMinrttFieldNumber = 1704, kDctcpInfoEnabledFieldNumber = 1801, kDctcpInfoCeStateFieldNumber = 1802, kDctcpInfoAlphaFieldNumber = 1803, @@ -571,9 +574,9 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo kBbrInfoMinRttFieldNumber = 1903, kBbrInfoPacingGainFieldNumber = 1904, kBbrInfoCwndGainFieldNumber = 1905, - kClassIdFieldNumber = 2001, - kCGroupFieldNumber = 2103, - kSockOptFieldNumber = 2002, + kInetDiagClassIdFieldNumber = 2001, + kInetDiagCgroupIdFieldNumber = 2003, + kInetDiagSockoptFieldNumber = 2002, }; // string daemon_version = 2 [json_name = "daemonVersion"]; void clear_daemon_version() ; @@ -799,6 +802,16 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t _internal_socket_fd() const; void _internal_set_socket_fd(::uint64_t value); + public: + // uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; + void clear_enrich_socket_dest_next_hop_asn() ; + [[nodiscard]] ::uint64_t enrich_socket_dest_next_hop_asn() const; + void set_enrich_socket_dest_next_hop_asn(::uint64_t value); + + private: + ::uint64_t _internal_enrich_socket_dest_next_hop_asn() const; + void _internal_set_enrich_socket_dest_next_hop_asn(::uint64_t value); + public: // uint32 uplink1_nic_pci_vendor = 103 [json_name = "uplink1NicPciVendor"]; void clear_uplink1_nic_pci_vendor() ; @@ -809,16 +822,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_uplink1_nic_pci_vendor() const; void _internal_set_uplink1_nic_pci_vendor(::uint32_t value); - public: - // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; - void clear_inet_diag_msg_socket_interface() ; - [[nodiscard]] ::uint32_t inet_diag_msg_socket_interface() const; - void set_inet_diag_msg_socket_interface(::uint32_t value); - - private: - ::uint32_t _internal_inet_diag_msg_socket_interface() const; - void _internal_set_inet_diag_msg_socket_interface(::uint32_t value); - public: // string uplink1_ifname = 100 [json_name = "uplink1Ifname"]; void clear_uplink1_ifname() ; @@ -1104,6 +1107,51 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo PROTOBUF_ALWAYS_INLINE void _internal_set_uplink2_lldp_port_descr(const ::std::string& value); ::std::string* PROTOBUF_NONNULL _internal_mutable_uplink2_lldp_port_descr(); + public: + // string enrich_socket_interface_name = 300 [json_name = "enrichSocketInterfaceName"]; + void clear_enrich_socket_interface_name() ; + [[nodiscard]] const ::std::string& enrich_socket_interface_name() const; + template + void set_enrich_socket_interface_name(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_enrich_socket_interface_name(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_enrich_socket_interface_name(); + void set_allocated_enrich_socket_interface_name(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_enrich_socket_interface_name() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_enrich_socket_interface_name(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_enrich_socket_interface_name(); + + public: + // string enrich_socket_dest_egress_ifname = 312 [json_name = "enrichSocketDestEgressIfname"]; + void clear_enrich_socket_dest_egress_ifname() ; + [[nodiscard]] const ::std::string& enrich_socket_dest_egress_ifname() const; + template + void set_enrich_socket_dest_egress_ifname(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_enrich_socket_dest_egress_ifname(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_enrich_socket_dest_egress_ifname(); + void set_allocated_enrich_socket_dest_egress_ifname(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_enrich_socket_dest_egress_ifname() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_enrich_socket_dest_egress_ifname(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_enrich_socket_dest_egress_ifname(); + + public: + // string enrich_socket_dest_network_owner = 322 [json_name = "enrichSocketDestNetworkOwner"]; + void clear_enrich_socket_dest_network_owner() ; + [[nodiscard]] const ::std::string& enrich_socket_dest_network_owner() const; + template + void set_enrich_socket_dest_network_owner(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_enrich_socket_dest_network_owner(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_enrich_socket_dest_network_owner(); + void set_allocated_enrich_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_enrich_socket_dest_network_owner() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_enrich_socket_dest_network_owner(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_enrich_socket_dest_network_owner(); + public: // bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; void clear_inet_diag_msg_socket_source() ; @@ -1135,34 +1183,19 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::std::string* PROTOBUF_NONNULL _internal_mutable_inet_diag_msg_socket_destination(); public: - // string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; - void clear_inet_diag_msg_socket_dest_network_owner() ; - [[nodiscard]] const ::std::string& inet_diag_msg_socket_dest_network_owner() const; - template - void set_inet_diag_msg_socket_dest_network_owner(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_inet_diag_msg_socket_dest_network_owner(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_inet_diag_msg_socket_dest_network_owner(); - void set_allocated_inet_diag_msg_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_inet_diag_msg_socket_dest_network_owner() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_inet_diag_msg_socket_dest_network_owner(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_inet_diag_msg_socket_dest_network_owner(); - - public: - // string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; - void clear_congestion_algorithm_string() ; - [[nodiscard]] const ::std::string& congestion_algorithm_string() const; + // string inet_diag_cong = 1300 [json_name = "inetDiagCong"]; + void clear_inet_diag_cong() ; + [[nodiscard]] const ::std::string& inet_diag_cong() const; template - void set_congestion_algorithm_string(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_congestion_algorithm_string(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_congestion_algorithm_string(); - void set_allocated_congestion_algorithm_string(::std::string* PROTOBUF_NULLABLE value); + void set_inet_diag_cong(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_inet_diag_cong(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_inet_diag_cong(); + void set_allocated_inet_diag_cong(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_congestion_algorithm_string() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_congestion_algorithm_string(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_congestion_algorithm_string(); + const ::std::string& _internal_inet_diag_cong() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_inet_diag_cong(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_inet_diag_cong(); public: // uint64 netlinker_id = 62 [json_name = "netlinkerId"]; @@ -1224,6 +1257,36 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_uplink2_nic_speed_mbps() const; void _internal_set_uplink2_nic_speed_mbps(::uint32_t value); + public: + // .xtcp_flat_record.v1.XtcpFlatRecord.Locality enrich_socket_dest_locality = 310 [json_name = "enrichSocketDestLocality"]; + void clear_enrich_socket_dest_locality() ; + [[nodiscard]] ::xtcp_flat_record::v1::XtcpFlatRecord_Locality enrich_socket_dest_locality() const; + void set_enrich_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); + + private: + ::xtcp_flat_record::v1::XtcpFlatRecord_Locality _internal_enrich_socket_dest_locality() const; + void _internal_set_enrich_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); + + public: + // uint64 enrich_socket_dest_asn = 320 [json_name = "enrichSocketDestAsn"]; + void clear_enrich_socket_dest_asn() ; + [[nodiscard]] ::uint64_t enrich_socket_dest_asn() const; + void set_enrich_socket_dest_asn(::uint64_t value); + + private: + ::uint64_t _internal_enrich_socket_dest_asn() const; + void _internal_set_enrich_socket_dest_asn(::uint64_t value); + + public: + // uint32 enrich_socket_dest_egress_ifindex = 311 [json_name = "enrichSocketDestEgressIfindex"]; + void clear_enrich_socket_dest_egress_ifindex() ; + [[nodiscard]] ::uint32_t enrich_socket_dest_egress_ifindex() const; + void set_enrich_socket_dest_egress_ifindex(::uint32_t value); + + private: + ::uint32_t _internal_enrich_socket_dest_egress_ifindex() const; + void _internal_set_enrich_socket_dest_egress_ifindex(::uint32_t value); + public: // uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; void clear_inet_diag_msg_family() ; @@ -1285,14 +1348,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_inet_diag_msg_socket_destination_port(::uint32_t value); public: - // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; - void clear_inet_diag_msg_expires() ; - [[nodiscard]] ::uint32_t inet_diag_msg_expires() const; - void set_inet_diag_msg_expires(::uint32_t value); + // uint32 inet_diag_msg_socket_interface = 1009 [json_name = "inetDiagMsgSocketInterface"]; + void clear_inet_diag_msg_socket_interface() ; + [[nodiscard]] ::uint32_t inet_diag_msg_socket_interface() const; + void set_inet_diag_msg_socket_interface(::uint32_t value); private: - ::uint32_t _internal_inet_diag_msg_expires() const; - void _internal_set_inet_diag_msg_expires(::uint32_t value); + ::uint32_t _internal_inet_diag_msg_socket_interface() const; + void _internal_set_inet_diag_msg_socket_interface(::uint32_t value); public: // uint64 inet_diag_msg_socket_cookie = 1010 [json_name = "inetDiagMsgSocketCookie"]; @@ -1305,24 +1368,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_inet_diag_msg_socket_cookie(::uint64_t value); public: - // uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; - void clear_inet_diag_msg_socket_dest_asn() ; - [[nodiscard]] ::uint64_t inet_diag_msg_socket_dest_asn() const; - void set_inet_diag_msg_socket_dest_asn(::uint64_t value); - - private: - ::uint64_t _internal_inet_diag_msg_socket_dest_asn() const; - void _internal_set_inet_diag_msg_socket_dest_asn(::uint64_t value); - - public: - // uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; - void clear_inet_diag_msg_socket_next_hop_asn() ; - [[nodiscard]] ::uint64_t inet_diag_msg_socket_next_hop_asn() const; - void set_inet_diag_msg_socket_next_hop_asn(::uint64_t value); + // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; + void clear_inet_diag_msg_expires() ; + [[nodiscard]] ::uint32_t inet_diag_msg_expires() const; + void set_inet_diag_msg_expires(::uint32_t value); private: - ::uint64_t _internal_inet_diag_msg_socket_next_hop_asn() const; - void _internal_set_inet_diag_msg_socket_next_hop_asn(::uint64_t value); + ::uint32_t _internal_inet_diag_msg_expires() const; + void _internal_set_inet_diag_msg_expires(::uint32_t value); public: // uint32 inet_diag_msg_rqueue = 1014 [json_name = "inetDiagMsgRqueue"]; @@ -1364,16 +1417,6 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t _internal_inet_diag_msg_inode() const; void _internal_set_inet_diag_msg_inode(::uint32_t value); - public: - // .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; - void clear_inet_diag_msg_socket_dest_locality() ; - [[nodiscard]] ::xtcp_flat_record::v1::XtcpFlatRecord_Locality inet_diag_msg_socket_dest_locality() const; - void set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); - - private: - ::xtcp_flat_record::v1::XtcpFlatRecord_Locality _internal_inet_diag_msg_socket_dest_locality() const; - void _internal_set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value); - public: // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; void clear_mem_info_rmem() ; @@ -1475,24 +1518,24 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_options(::uint32_t value); public: - // uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; - void clear_tcp_info_send_scale() ; - [[nodiscard]] ::uint32_t tcp_info_send_scale() const; - void set_tcp_info_send_scale(::uint32_t value); + // uint32 tcp_info_snd_wscale = 1207 [json_name = "tcpInfoSndWscale"]; + void clear_tcp_info_snd_wscale() ; + [[nodiscard]] ::uint32_t tcp_info_snd_wscale() const; + void set_tcp_info_snd_wscale(::uint32_t value); private: - ::uint32_t _internal_tcp_info_send_scale() const; - void _internal_set_tcp_info_send_scale(::uint32_t value); + ::uint32_t _internal_tcp_info_snd_wscale() const; + void _internal_set_tcp_info_snd_wscale(::uint32_t value); public: - // uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; - void clear_tcp_info_rcv_scale() ; - [[nodiscard]] ::uint32_t tcp_info_rcv_scale() const; - void set_tcp_info_rcv_scale(::uint32_t value); + // uint32 tcp_info_rcv_wscale = 1208 [json_name = "tcpInfoRcvWscale"]; + void clear_tcp_info_rcv_wscale() ; + [[nodiscard]] ::uint32_t tcp_info_rcv_wscale() const; + void set_tcp_info_rcv_wscale(::uint32_t value); private: - ::uint32_t _internal_tcp_info_rcv_scale() const; - void _internal_set_tcp_info_rcv_scale(::uint32_t value); + ::uint32_t _internal_tcp_info_rcv_wscale() const; + void _internal_set_tcp_info_rcv_wscale(::uint32_t value); public: // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; @@ -1505,14 +1548,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_delivery_rate_app_limited(::uint32_t value); public: - // uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; - void clear_tcp_info_fast_open_client_failed() ; - [[nodiscard]] ::uint32_t tcp_info_fast_open_client_failed() const; - void set_tcp_info_fast_open_client_failed(::uint32_t value); + // uint32 tcp_info_fastopen_client_fail = 1210 [json_name = "tcpInfoFastopenClientFail"]; + void clear_tcp_info_fastopen_client_fail() ; + [[nodiscard]] ::uint32_t tcp_info_fastopen_client_fail() const; + void set_tcp_info_fastopen_client_fail(::uint32_t value); private: - ::uint32_t _internal_tcp_info_fast_open_client_failed() const; - void _internal_set_tcp_info_fast_open_client_failed(::uint32_t value); + ::uint32_t _internal_tcp_info_fastopen_client_fail() const; + void _internal_set_tcp_info_fastopen_client_fail(::uint32_t value); public: // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; @@ -1675,14 +1718,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_rtt(::uint32_t value); public: - // uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; - void clear_tcp_info_rtt_var() ; - [[nodiscard]] ::uint32_t tcp_info_rtt_var() const; - void set_tcp_info_rtt_var(::uint32_t value); + // uint32 tcp_info_rttvar = 1231 [json_name = "tcpInfoRttvar"]; + void clear_tcp_info_rttvar() ; + [[nodiscard]] ::uint32_t tcp_info_rttvar() const; + void set_tcp_info_rttvar(::uint32_t value); private: - ::uint32_t _internal_tcp_info_rtt_var() const; - void _internal_set_tcp_info_rtt_var(::uint32_t value); + ::uint32_t _internal_tcp_info_rttvar() const; + void _internal_set_tcp_info_rttvar(::uint32_t value); public: // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; @@ -1705,14 +1748,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_snd_cwnd(::uint32_t value); public: - // uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; - void clear_tcp_info_adv_mss() ; - [[nodiscard]] ::uint32_t tcp_info_adv_mss() const; - void set_tcp_info_adv_mss(::uint32_t value); + // uint32 tcp_info_advmss = 1234 [json_name = "tcpInfoAdvmss"]; + void clear_tcp_info_advmss() ; + [[nodiscard]] ::uint32_t tcp_info_advmss() const; + void set_tcp_info_advmss(::uint32_t value); private: - ::uint32_t _internal_tcp_info_adv_mss() const; - void _internal_set_tcp_info_adv_mss(::uint32_t value); + ::uint32_t _internal_tcp_info_advmss() const; + void _internal_set_tcp_info_advmss(::uint32_t value); public: // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; @@ -1815,14 +1858,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_segs_in(::uint32_t value); public: - // uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; - void clear_tcp_info_not_sent_bytes() ; - [[nodiscard]] ::uint32_t tcp_info_not_sent_bytes() const; - void set_tcp_info_not_sent_bytes(::uint32_t value); + // uint32 tcp_info_notsent_bytes = 1245 [json_name = "tcpInfoNotsentBytes"]; + void clear_tcp_info_notsent_bytes() ; + [[nodiscard]] ::uint32_t tcp_info_notsent_bytes() const; + void set_tcp_info_notsent_bytes(::uint32_t value); private: - ::uint32_t _internal_tcp_info_not_sent_bytes() const; - void _internal_set_tcp_info_not_sent_bytes(::uint32_t value); + ::uint32_t _internal_tcp_info_notsent_bytes() const; + void _internal_set_tcp_info_notsent_bytes(::uint32_t value); public: // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; @@ -2025,34 +2068,34 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_tcp_info_total_rto_time(::uint32_t value); public: - // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; - void clear_congestion_algorithm_enum() ; - [[nodiscard]] ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm congestion_algorithm_enum() const; - void set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value); + // .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm inet_diag_cong_enum = 1301 [json_name = "inetDiagCongEnum"]; + void clear_inet_diag_cong_enum() ; + [[nodiscard]] ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm inet_diag_cong_enum() const; + void set_inet_diag_cong_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value); private: - ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm _internal_congestion_algorithm_enum() const; - void _internal_set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value); + ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm _internal_inet_diag_cong_enum() const; + void _internal_set_inet_diag_cong_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value); public: - // uint32 type_of_service = 1401 [json_name = "typeOfService"]; - void clear_type_of_service() ; - [[nodiscard]] ::uint32_t type_of_service() const; - void set_type_of_service(::uint32_t value); + // uint32 inet_diag_tos = 1401 [json_name = "inetDiagTos"]; + void clear_inet_diag_tos() ; + [[nodiscard]] ::uint32_t inet_diag_tos() const; + void set_inet_diag_tos(::uint32_t value); private: - ::uint32_t _internal_type_of_service() const; - void _internal_set_type_of_service(::uint32_t value); + ::uint32_t _internal_inet_diag_tos() const; + void _internal_set_inet_diag_tos(::uint32_t value); public: - // uint32 traffic_class = 1402 [json_name = "trafficClass"]; - void clear_traffic_class() ; - [[nodiscard]] ::uint32_t traffic_class() const; - void set_traffic_class(::uint32_t value); + // uint32 inet_diag_tclass = 1402 [json_name = "inetDiagTclass"]; + void clear_inet_diag_tclass() ; + [[nodiscard]] ::uint32_t inet_diag_tclass() const; + void set_inet_diag_tclass(::uint32_t value); private: - ::uint32_t _internal_traffic_class() const; - void _internal_set_traffic_class(::uint32_t value); + ::uint32_t _internal_inet_diag_tclass() const; + void _internal_set_inet_diag_tclass(::uint32_t value); public: // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; @@ -2065,14 +2108,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_sk_mem_info_rmem_alloc(::uint32_t value); public: - // uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; - void clear_sk_mem_info_rcv_buf() ; - [[nodiscard]] ::uint32_t sk_mem_info_rcv_buf() const; - void set_sk_mem_info_rcv_buf(::uint32_t value); + // uint32 sk_mem_info_rcvbuf = 1502 [json_name = "skMemInfoRcvbuf"]; + void clear_sk_mem_info_rcvbuf() ; + [[nodiscard]] ::uint32_t sk_mem_info_rcvbuf() const; + void set_sk_mem_info_rcvbuf(::uint32_t value); private: - ::uint32_t _internal_sk_mem_info_rcv_buf() const; - void _internal_set_sk_mem_info_rcv_buf(::uint32_t value); + ::uint32_t _internal_sk_mem_info_rcvbuf() const; + void _internal_set_sk_mem_info_rcvbuf(::uint32_t value); public: // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; @@ -2085,14 +2128,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_sk_mem_info_wmem_alloc(::uint32_t value); public: - // uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; - void clear_sk_mem_info_snd_buf() ; - [[nodiscard]] ::uint32_t sk_mem_info_snd_buf() const; - void set_sk_mem_info_snd_buf(::uint32_t value); + // uint32 sk_mem_info_sndbuf = 1504 [json_name = "skMemInfoSndbuf"]; + void clear_sk_mem_info_sndbuf() ; + [[nodiscard]] ::uint32_t sk_mem_info_sndbuf() const; + void set_sk_mem_info_sndbuf(::uint32_t value); private: - ::uint32_t _internal_sk_mem_info_snd_buf() const; - void _internal_set_sk_mem_info_snd_buf(::uint32_t value); + ::uint32_t _internal_sk_mem_info_sndbuf() const; + void _internal_set_sk_mem_info_sndbuf(::uint32_t value); public: // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; @@ -2145,14 +2188,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_sk_mem_info_drops(::uint32_t value); public: - // uint32 shutdown_state = 1600 [json_name = "shutdownState"]; - void clear_shutdown_state() ; - [[nodiscard]] ::uint32_t shutdown_state() const; - void set_shutdown_state(::uint32_t value); + // uint32 inet_diag_shutdown = 1600 [json_name = "inetDiagShutdown"]; + void clear_inet_diag_shutdown() ; + [[nodiscard]] ::uint32_t inet_diag_shutdown() const; + void set_inet_diag_shutdown(::uint32_t value); private: - ::uint32_t _internal_shutdown_state() const; - void _internal_set_shutdown_state(::uint32_t value); + ::uint32_t _internal_inet_diag_shutdown() const; + void _internal_set_inet_diag_shutdown(::uint32_t value); public: // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; @@ -2165,14 +2208,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_vegas_info_enabled(::uint32_t value); public: - // uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; - void clear_vegas_info_rtt_cnt() ; - [[nodiscard]] ::uint32_t vegas_info_rtt_cnt() const; - void set_vegas_info_rtt_cnt(::uint32_t value); + // uint32 vegas_info_rttcnt = 1702 [json_name = "vegasInfoRttcnt"]; + void clear_vegas_info_rttcnt() ; + [[nodiscard]] ::uint32_t vegas_info_rttcnt() const; + void set_vegas_info_rttcnt(::uint32_t value); private: - ::uint32_t _internal_vegas_info_rtt_cnt() const; - void _internal_set_vegas_info_rtt_cnt(::uint32_t value); + ::uint32_t _internal_vegas_info_rttcnt() const; + void _internal_set_vegas_info_rttcnt(::uint32_t value); public: // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; @@ -2185,14 +2228,14 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_vegas_info_rtt(::uint32_t value); public: - // uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; - void clear_vegas_info_min_rtt() ; - [[nodiscard]] ::uint32_t vegas_info_min_rtt() const; - void set_vegas_info_min_rtt(::uint32_t value); + // uint32 vegas_info_minrtt = 1704 [json_name = "vegasInfoMinrtt"]; + void clear_vegas_info_minrtt() ; + [[nodiscard]] ::uint32_t vegas_info_minrtt() const; + void set_vegas_info_minrtt(::uint32_t value); private: - ::uint32_t _internal_vegas_info_min_rtt() const; - void _internal_set_vegas_info_min_rtt(::uint32_t value); + ::uint32_t _internal_vegas_info_minrtt() const; + void _internal_set_vegas_info_minrtt(::uint32_t value); public: // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; @@ -2295,43 +2338,43 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo void _internal_set_bbr_info_cwnd_gain(::uint32_t value); public: - // uint32 class_id = 2001 [json_name = "classId"]; - void clear_class_id() ; - [[nodiscard]] ::uint32_t class_id() const; - void set_class_id(::uint32_t value); + // uint32 inet_diag_class_id = 2001 [json_name = "inetDiagClassId"]; + void clear_inet_diag_class_id() ; + [[nodiscard]] ::uint32_t inet_diag_class_id() const; + void set_inet_diag_class_id(::uint32_t value); private: - ::uint32_t _internal_class_id() const; - void _internal_set_class_id(::uint32_t value); + ::uint32_t _internal_inet_diag_class_id() const; + void _internal_set_inet_diag_class_id(::uint32_t value); public: - // uint64 c_group = 2103 [json_name = "cGroup"]; - void clear_c_group() ; - [[nodiscard]] ::uint64_t c_group() const; - void set_c_group(::uint64_t value); + // uint64 inet_diag_cgroup_id = 2003 [json_name = "inetDiagCgroupId"]; + void clear_inet_diag_cgroup_id() ; + [[nodiscard]] ::uint64_t inet_diag_cgroup_id() const; + void set_inet_diag_cgroup_id(::uint64_t value); private: - ::uint64_t _internal_c_group() const; - void _internal_set_c_group(::uint64_t value); + ::uint64_t _internal_inet_diag_cgroup_id() const; + void _internal_set_inet_diag_cgroup_id(::uint64_t value); public: - // uint32 sock_opt = 2002 [json_name = "sockOpt"]; - void clear_sock_opt() ; - [[nodiscard]] ::uint32_t sock_opt() const; - void set_sock_opt(::uint32_t value); + // uint32 inet_diag_sockopt = 2002 [json_name = "inetDiagSockopt"]; + void clear_inet_diag_sockopt() ; + [[nodiscard]] ::uint32_t inet_diag_sockopt() const; + void set_inet_diag_sockopt(::uint32_t value); private: - ::uint32_t _internal_sock_opt() const; - void _internal_set_sock_opt(::uint32_t value); + ::uint32_t _internal_inet_diag_sockopt() const; + void _internal_set_inet_diag_sockopt(::uint32_t value); public: // @@protoc_insertion_point(class_scope:xtcp_flat_record.v1.XtcpFlatRecord) private: class _Internal; using ParseTableT_ = - ::google::protobuf::internal::TcParseTable<5, 158, - 0, 766, - 103>; + ::google::protobuf::internal::TcParseTable<5, 161, + 0, 814, + 110>; static constexpr ParseTableT_ InternalGenerateParseTable_( const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data); friend class ::google::protobuf::internal::TcParser; @@ -2356,7 +2399,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, const XtcpFlatRecord& from_msg); - ::google::protobuf::internal::HasBits<5> _has_bits_; + ::google::protobuf::internal::HasBits<6> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; ::google::protobuf::internal::ArenaStringPtr daemon_version_; ::google::protobuf::internal::ArenaStringPtr hostname_; @@ -2375,8 +2418,8 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t netns_inode_; ::uint64_t record_counter_; ::uint64_t socket_fd_; + ::uint64_t enrich_socket_dest_next_hop_asn_; ::uint32_t uplink1_nic_pci_vendor_; - ::uint32_t inet_diag_msg_socket_interface_; ::google::protobuf::internal::ArenaStringPtr uplink1_ifname_; ::google::protobuf::internal::ArenaStringPtr uplink1_nic_driver_; ::google::protobuf::internal::ArenaStringPtr uplink1_nic_bus_info_; @@ -2396,31 +2439,34 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::google::protobuf::internal::ArenaStringPtr uplink2_lldp_mgmt_ip_; ::google::protobuf::internal::ArenaStringPtr uplink2_lldp_port_id_; ::google::protobuf::internal::ArenaStringPtr uplink2_lldp_port_descr_; + ::google::protobuf::internal::ArenaStringPtr enrich_socket_interface_name_; + ::google::protobuf::internal::ArenaStringPtr enrich_socket_dest_egress_ifname_; + ::google::protobuf::internal::ArenaStringPtr enrich_socket_dest_network_owner_; ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_source_; ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_destination_; - ::google::protobuf::internal::ArenaStringPtr inet_diag_msg_socket_dest_network_owner_; - ::google::protobuf::internal::ArenaStringPtr congestion_algorithm_string_; + ::google::protobuf::internal::ArenaStringPtr inet_diag_cong_; ::uint64_t netlinker_id_; ::uint32_t uplink1_nic_pci_device_; ::uint32_t uplink1_nic_speed_mbps_; ::uint32_t uplink2_nic_pci_vendor_; ::uint32_t uplink2_nic_pci_device_; ::uint32_t uplink2_nic_speed_mbps_; + int enrich_socket_dest_locality_; + ::uint64_t enrich_socket_dest_asn_; + ::uint32_t enrich_socket_dest_egress_ifindex_; ::uint32_t inet_diag_msg_family_; ::uint32_t inet_diag_msg_state_; ::uint32_t inet_diag_msg_timer_; ::uint32_t inet_diag_msg_retrans_; ::uint32_t inet_diag_msg_socket_source_port_; ::uint32_t inet_diag_msg_socket_destination_port_; - ::uint32_t inet_diag_msg_expires_; + ::uint32_t inet_diag_msg_socket_interface_; ::uint64_t inet_diag_msg_socket_cookie_; - ::uint64_t inet_diag_msg_socket_dest_asn_; - ::uint64_t inet_diag_msg_socket_next_hop_asn_; + ::uint32_t inet_diag_msg_expires_; ::uint32_t inet_diag_msg_rqueue_; ::uint32_t inet_diag_msg_wqueue_; ::uint32_t inet_diag_msg_uid_; ::uint32_t inet_diag_msg_inode_; - int inet_diag_msg_socket_dest_locality_; ::uint32_t mem_info_rmem_; ::uint32_t mem_info_wmem_; ::uint32_t mem_info_fmem_; @@ -2431,10 +2477,10 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t tcp_info_probes_; ::uint32_t tcp_info_backoff_; ::uint32_t tcp_info_options_; - ::uint32_t tcp_info_send_scale_; - ::uint32_t tcp_info_rcv_scale_; + ::uint32_t tcp_info_snd_wscale_; + ::uint32_t tcp_info_rcv_wscale_; ::uint32_t tcp_info_delivery_rate_app_limited_; - ::uint32_t tcp_info_fast_open_client_failed_; + ::uint32_t tcp_info_fastopen_client_fail_; ::uint32_t tcp_info_rto_; ::uint32_t tcp_info_ato_; ::uint32_t tcp_info_snd_mss_; @@ -2451,10 +2497,10 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t tcp_info_pmtu_; ::uint32_t tcp_info_rcv_ssthresh_; ::uint32_t tcp_info_rtt_; - ::uint32_t tcp_info_rtt_var_; + ::uint32_t tcp_info_rttvar_; ::uint32_t tcp_info_snd_ssthresh_; ::uint32_t tcp_info_snd_cwnd_; - ::uint32_t tcp_info_adv_mss_; + ::uint32_t tcp_info_advmss_; ::uint32_t tcp_info_reordering_; ::uint32_t tcp_info_rcv_rtt_; ::uint32_t tcp_info_rcv_space_; @@ -2465,7 +2511,7 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint64_t tcp_info_bytes_acked_; ::uint64_t tcp_info_bytes_received_; ::uint32_t tcp_info_segs_in_; - ::uint32_t tcp_info_not_sent_bytes_; + ::uint32_t tcp_info_notsent_bytes_; ::uint32_t tcp_info_min_rtt_; ::uint32_t tcp_info_data_segs_in_; ::uint64_t tcp_info_delivery_rate_; @@ -2486,23 +2532,23 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t tcp_info_total_rto_; ::uint32_t tcp_info_total_rto_recoveries_; ::uint32_t tcp_info_total_rto_time_; - int congestion_algorithm_enum_; - ::uint32_t type_of_service_; - ::uint32_t traffic_class_; + int inet_diag_cong_enum_; + ::uint32_t inet_diag_tos_; + ::uint32_t inet_diag_tclass_; ::uint32_t sk_mem_info_rmem_alloc_; - ::uint32_t sk_mem_info_rcv_buf_; + ::uint32_t sk_mem_info_rcvbuf_; ::uint32_t sk_mem_info_wmem_alloc_; - ::uint32_t sk_mem_info_snd_buf_; + ::uint32_t sk_mem_info_sndbuf_; ::uint32_t sk_mem_info_fwd_alloc_; ::uint32_t sk_mem_info_wmem_queued_; ::uint32_t sk_mem_info_optmem_; ::uint32_t sk_mem_info_backlog_; ::uint32_t sk_mem_info_drops_; - ::uint32_t shutdown_state_; + ::uint32_t inet_diag_shutdown_; ::uint32_t vegas_info_enabled_; - ::uint32_t vegas_info_rtt_cnt_; + ::uint32_t vegas_info_rttcnt_; ::uint32_t vegas_info_rtt_; - ::uint32_t vegas_info_min_rtt_; + ::uint32_t vegas_info_minrtt_; ::uint32_t dctcp_info_enabled_; ::uint32_t dctcp_info_ce_state_; ::uint32_t dctcp_info_alpha_; @@ -2513,9 +2559,9 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED XtcpFlatRecord final : public ::goo ::uint32_t bbr_info_min_rtt_; ::uint32_t bbr_info_pacing_gain_; ::uint32_t bbr_info_cwnd_gain_; - ::uint32_t class_id_; - ::uint64_t c_group_; - ::uint32_t sock_opt_; + ::uint32_t inet_diag_class_id_; + ::uint64_t inet_diag_cgroup_id_; + ::uint32_t inet_diag_sockopt_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; @@ -4287,7 +4333,7 @@ inline void XtcpFlatRecord::_internal_set_socket_fd(::uint64_t value) { inline void XtcpFlatRecord::clear_netlinker_id() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.netlinker_id_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00000400U); + ClearHasBit(_impl_._has_bits_[1], 0x00001000U); } inline ::uint64_t XtcpFlatRecord::netlinker_id() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.netlinker_id) @@ -4295,7 +4341,7 @@ inline ::uint64_t XtcpFlatRecord::netlinker_id() const { } inline void XtcpFlatRecord::set_netlinker_id(::uint64_t value) { _internal_set_netlinker_id(value); - SetHasBit(_impl_._has_bits_[1], 0x00000400U); + SetHasBit(_impl_._has_bits_[1], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.netlinker_id) } inline ::uint64_t XtcpFlatRecord::_internal_netlinker_id() const { @@ -4503,7 +4549,7 @@ inline void XtcpFlatRecord::set_allocated_uplink1_nic_model(::std::string* PROTO inline void XtcpFlatRecord::clear_uplink1_nic_pci_vendor() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink1_nic_pci_vendor_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00020000U); + ClearHasBit(_impl_._has_bits_[0], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_vendor() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_vendor) @@ -4511,7 +4557,7 @@ inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_vendor() const { } inline void XtcpFlatRecord::set_uplink1_nic_pci_vendor(::uint32_t value) { _internal_set_uplink1_nic_pci_vendor(value); - SetHasBit(_impl_._has_bits_[0], 0x00020000U); + SetHasBit(_impl_._has_bits_[0], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_vendor) } inline ::uint32_t XtcpFlatRecord::_internal_uplink1_nic_pci_vendor() const { @@ -4527,7 +4573,7 @@ inline void XtcpFlatRecord::_internal_set_uplink1_nic_pci_vendor(::uint32_t valu inline void XtcpFlatRecord::clear_uplink1_nic_pci_device() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink1_nic_pci_device_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + ClearHasBit(_impl_._has_bits_[1], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_device() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_device) @@ -4535,7 +4581,7 @@ inline ::uint32_t XtcpFlatRecord::uplink1_nic_pci_device() const { } inline void XtcpFlatRecord::set_uplink1_nic_pci_device(::uint32_t value) { _internal_set_uplink1_nic_pci_device(value); - SetHasBit(_impl_._has_bits_[1], 0x00000800U); + SetHasBit(_impl_._has_bits_[1], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_pci_device) } inline ::uint32_t XtcpFlatRecord::_internal_uplink1_nic_pci_device() const { @@ -4615,7 +4661,7 @@ inline void XtcpFlatRecord::set_allocated_uplink1_nic_bus_info(::std::string* PR inline void XtcpFlatRecord::clear_uplink1_nic_speed_mbps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink1_nic_speed_mbps_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00001000U); + ClearHasBit(_impl_._has_bits_[1], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::uplink1_nic_speed_mbps() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_speed_mbps) @@ -4623,7 +4669,7 @@ inline ::uint32_t XtcpFlatRecord::uplink1_nic_speed_mbps() const { } inline void XtcpFlatRecord::set_uplink1_nic_speed_mbps(::uint32_t value) { _internal_set_uplink1_nic_speed_mbps(value); - SetHasBit(_impl_._has_bits_[1], 0x00001000U); + SetHasBit(_impl_._has_bits_[1], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink1_nic_speed_mbps) } inline ::uint32_t XtcpFlatRecord::_internal_uplink1_nic_speed_mbps() const { @@ -5215,7 +5261,7 @@ inline void XtcpFlatRecord::set_allocated_uplink2_nic_model(::std::string* PROTO inline void XtcpFlatRecord::clear_uplink2_nic_pci_vendor() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_pci_vendor_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00002000U); + ClearHasBit(_impl_._has_bits_[1], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_vendor() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_vendor) @@ -5223,7 +5269,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_vendor() const { } inline void XtcpFlatRecord::set_uplink2_nic_pci_vendor(::uint32_t value) { _internal_set_uplink2_nic_pci_vendor(value); - SetHasBit(_impl_._has_bits_[1], 0x00002000U); + SetHasBit(_impl_._has_bits_[1], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_vendor) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_pci_vendor() const { @@ -5239,7 +5285,7 @@ inline void XtcpFlatRecord::_internal_set_uplink2_nic_pci_vendor(::uint32_t valu inline void XtcpFlatRecord::clear_uplink2_nic_pci_device() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_pci_device_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00004000U); + ClearHasBit(_impl_._has_bits_[1], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_device() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_device) @@ -5247,7 +5293,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_pci_device() const { } inline void XtcpFlatRecord::set_uplink2_nic_pci_device(::uint32_t value) { _internal_set_uplink2_nic_pci_device(value); - SetHasBit(_impl_._has_bits_[1], 0x00004000U); + SetHasBit(_impl_._has_bits_[1], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_pci_device) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_pci_device() const { @@ -5327,7 +5373,7 @@ inline void XtcpFlatRecord::set_allocated_uplink2_nic_bus_info(::std::string* PR inline void XtcpFlatRecord::clear_uplink2_nic_speed_mbps() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.uplink2_nic_speed_mbps_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00008000U); + ClearHasBit(_impl_._has_bits_[1], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::uplink2_nic_speed_mbps() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_speed_mbps) @@ -5335,7 +5381,7 @@ inline ::uint32_t XtcpFlatRecord::uplink2_nic_speed_mbps() const { } inline void XtcpFlatRecord::set_uplink2_nic_speed_mbps(::uint32_t value) { _internal_set_uplink2_nic_speed_mbps(value); - SetHasBit(_impl_._has_bits_[1], 0x00008000U); + SetHasBit(_impl_._has_bits_[1], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_nic_speed_mbps) } inline ::uint32_t XtcpFlatRecord::_internal_uplink2_nic_speed_mbps() const { @@ -5731,155 +5777,443 @@ inline void XtcpFlatRecord::set_allocated_uplink2_lldp_port_descr(::std::string* // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.uplink2_lldp_port_descr) } -// uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_family() { +// string enrich_socket_interface_name = 300 [json_name = "enrichSocketInterfaceName"]; +inline void XtcpFlatRecord::clear_enrich_socket_interface_name() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_family_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00010000U); + _impl_.enrich_socket_interface_name_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); } -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_family() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) - return _internal_inet_diag_msg_family(); +inline const ::std::string& XtcpFlatRecord::enrich_socket_interface_name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name) + return _internal_enrich_socket_interface_name(); } -inline void XtcpFlatRecord::set_inet_diag_msg_family(::uint32_t value) { - _internal_set_inet_diag_msg_family(value); - SetHasBit(_impl_._has_bits_[1], 0x00010000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) +template +PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_enrich_socket_interface_name(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000040U); + _impl_.enrich_socket_interface_name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name) } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_family() const { +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_enrich_socket_interface_name() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000040U); + ::std::string* _s = _internal_mutable_enrich_socket_interface_name(); + // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name) + return _s; +} +inline const ::std::string& XtcpFlatRecord::_internal_enrich_socket_interface_name() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_family_; + return _impl_.enrich_socket_interface_name_.Get(); } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_family(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_enrich_socket_interface_name(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_family_ = value; + _impl_.enrich_socket_interface_name_.Set(value, GetArena()); } - -// uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_state() { +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_enrich_socket_interface_name() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_state_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00020000U); -} -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_state() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) - return _internal_inet_diag_msg_state(); -} -inline void XtcpFlatRecord::set_inet_diag_msg_state(::uint32_t value) { - _internal_set_inet_diag_msg_state(value); - SetHasBit(_impl_._has_bits_[1], 0x00020000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) + return _impl_.enrich_socket_interface_name_.Mutable( GetArena()); } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_state() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_state_; +inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_enrich_socket_interface_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000040U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + auto* released = _impl_.enrich_socket_interface_name_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.enrich_socket_interface_name_.Set("", GetArena()); + } + return released; } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_state(::uint32_t value) { +inline void XtcpFlatRecord::set_allocated_enrich_socket_interface_name(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_state_ = value; + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000040U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + } + _impl_.enrich_socket_interface_name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.enrich_socket_interface_name_.IsDefault()) { + _impl_.enrich_socket_interface_name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_interface_name) } -// uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_timer() { +// .xtcp_flat_record.v1.XtcpFlatRecord.Locality enrich_socket_dest_locality = 310 [json_name = "enrichSocketDestLocality"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_locality() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_timer_ = 0u; + _impl_.enrich_socket_dest_locality_ = 0; ClearHasBit(_impl_._has_bits_[1], 0x00040000U); } -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_timer() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) - return _internal_inet_diag_msg_timer(); +inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::enrich_socket_dest_locality() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_locality) + return _internal_enrich_socket_dest_locality(); } -inline void XtcpFlatRecord::set_inet_diag_msg_timer(::uint32_t value) { - _internal_set_inet_diag_msg_timer(value); +inline void XtcpFlatRecord::set_enrich_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { + _internal_set_enrich_socket_dest_locality(value); SetHasBit(_impl_._has_bits_[1], 0x00040000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_locality) } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_timer() const { +inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::_internal_enrich_socket_dest_locality() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_timer_; + return static_cast<::xtcp_flat_record::v1::XtcpFlatRecord_Locality>(_impl_.enrich_socket_dest_locality_); } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_timer(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_timer_ = value; + _impl_.enrich_socket_dest_locality_ = value; } -// uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_retrans() { +// uint32 enrich_socket_dest_egress_ifindex = 311 [json_name = "enrichSocketDestEgressIfindex"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_egress_ifindex() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00080000U); + _impl_.enrich_socket_dest_egress_ifindex_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00100000U); } -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_retrans() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) - return _internal_inet_diag_msg_retrans(); +inline ::uint32_t XtcpFlatRecord::enrich_socket_dest_egress_ifindex() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifindex) + return _internal_enrich_socket_dest_egress_ifindex(); } -inline void XtcpFlatRecord::set_inet_diag_msg_retrans(::uint32_t value) { - _internal_set_inet_diag_msg_retrans(value); - SetHasBit(_impl_._has_bits_[1], 0x00080000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) +inline void XtcpFlatRecord::set_enrich_socket_dest_egress_ifindex(::uint32_t value) { + _internal_set_enrich_socket_dest_egress_ifindex(value); + SetHasBit(_impl_._has_bits_[1], 0x00100000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifindex) } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_retrans() const { +inline ::uint32_t XtcpFlatRecord::_internal_enrich_socket_dest_egress_ifindex() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_retrans_; + return _impl_.enrich_socket_dest_egress_ifindex_; } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_retrans(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_egress_ifindex(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_retrans_ = value; + _impl_.enrich_socket_dest_egress_ifindex_ = value; } -// uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_source_port() { +// string enrich_socket_dest_egress_ifname = 312 [json_name = "enrichSocketDestEgressIfname"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_egress_ifname() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_source_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00100000U); + _impl_.enrich_socket_dest_egress_ifname_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); } -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_source_port() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) - return _internal_inet_diag_msg_socket_source_port(); +inline const ::std::string& XtcpFlatRecord::enrich_socket_dest_egress_ifname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname) + return _internal_enrich_socket_dest_egress_ifname(); } -inline void XtcpFlatRecord::set_inet_diag_msg_socket_source_port(::uint32_t value) { - _internal_set_inet_diag_msg_socket_source_port(value); - SetHasBit(_impl_._has_bits_[1], 0x00100000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) +template +PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_enrich_socket_dest_egress_ifname(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000080U); + _impl_.enrich_socket_dest_egress_ifname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname) } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_source_port() const { +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_enrich_socket_dest_egress_ifname() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000080U); + ::std::string* _s = _internal_mutable_enrich_socket_dest_egress_ifname(); + // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname) + return _s; +} +inline const ::std::string& XtcpFlatRecord::_internal_enrich_socket_dest_egress_ifname() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_socket_source_port_; + return _impl_.enrich_socket_dest_egress_ifname_.Get(); } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_source_port(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_egress_ifname(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_source_port_ = value; + _impl_.enrich_socket_dest_egress_ifname_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_enrich_socket_dest_egress_ifname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.enrich_socket_dest_egress_ifname_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_enrich_socket_dest_egress_ifname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000080U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + auto* released = _impl_.enrich_socket_dest_egress_ifname_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.enrich_socket_dest_egress_ifname_.Set("", GetArena()); + } + return released; +} +inline void XtcpFlatRecord::set_allocated_enrich_socket_dest_egress_ifname(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000080U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + } + _impl_.enrich_socket_dest_egress_ifname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.enrich_socket_dest_egress_ifname_.IsDefault()) { + _impl_.enrich_socket_dest_egress_ifname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_egress_ifname) } -// uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_destination_port() { +// uint64 enrich_socket_dest_asn = 320 [json_name = "enrichSocketDestAsn"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_asn() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_destination_port_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00200000U); + _impl_.enrich_socket_dest_asn_ = ::uint64_t{0u}; + ClearHasBit(_impl_._has_bits_[1], 0x00080000U); } -inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_destination_port() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) - return _internal_inet_diag_msg_socket_destination_port(); +inline ::uint64_t XtcpFlatRecord::enrich_socket_dest_asn() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_asn) + return _internal_enrich_socket_dest_asn(); } -inline void XtcpFlatRecord::set_inet_diag_msg_socket_destination_port(::uint32_t value) { - _internal_set_inet_diag_msg_socket_destination_port(value); - SetHasBit(_impl_._has_bits_[1], 0x00200000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) +inline void XtcpFlatRecord::set_enrich_socket_dest_asn(::uint64_t value) { + _internal_set_enrich_socket_dest_asn(value); + SetHasBit(_impl_._has_bits_[1], 0x00080000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_asn) } -inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_destination_port() const { +inline ::uint64_t XtcpFlatRecord::_internal_enrich_socket_dest_asn() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_socket_destination_port_; + return _impl_.enrich_socket_dest_asn_; } -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_destination_port(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_asn(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_destination_port_ = value; + _impl_.enrich_socket_dest_asn_ = value; } -// bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; +// uint64 enrich_socket_dest_next_hop_asn = 321 [json_name = "enrichSocketDestNextHopAsn"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_next_hop_asn() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_socket_dest_next_hop_asn_ = ::uint64_t{0u}; + ClearHasBit(_impl_._has_bits_[0], 0x00020000U); +} +inline ::uint64_t XtcpFlatRecord::enrich_socket_dest_next_hop_asn() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_next_hop_asn) + return _internal_enrich_socket_dest_next_hop_asn(); +} +inline void XtcpFlatRecord::set_enrich_socket_dest_next_hop_asn(::uint64_t value) { + _internal_set_enrich_socket_dest_next_hop_asn(value); + SetHasBit(_impl_._has_bits_[0], 0x00020000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_next_hop_asn) +} +inline ::uint64_t XtcpFlatRecord::_internal_enrich_socket_dest_next_hop_asn() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.enrich_socket_dest_next_hop_asn_; +} +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_next_hop_asn(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_socket_dest_next_hop_asn_ = value; +} + +// string enrich_socket_dest_network_owner = 322 [json_name = "enrichSocketDestNetworkOwner"]; +inline void XtcpFlatRecord::clear_enrich_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_socket_dest_network_owner_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); +} +inline const ::std::string& XtcpFlatRecord::enrich_socket_dest_network_owner() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner) + return _internal_enrich_socket_dest_network_owner(); +} +template +PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_enrich_socket_dest_network_owner(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + _impl_.enrich_socket_dest_network_owner_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner) +} +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_enrich_socket_dest_network_owner() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + ::std::string* _s = _internal_mutable_enrich_socket_dest_network_owner(); + // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner) + return _s; +} +inline const ::std::string& XtcpFlatRecord::_internal_enrich_socket_dest_network_owner() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.enrich_socket_dest_network_owner_.Get(); +} +inline void XtcpFlatRecord::_internal_set_enrich_socket_dest_network_owner(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.enrich_socket_dest_network_owner_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_enrich_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.enrich_socket_dest_network_owner_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_enrich_socket_dest_network_owner() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + auto* released = _impl_.enrich_socket_dest_network_owner_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.enrich_socket_dest_network_owner_.Set("", GetArena()); + } + return released; +} +inline void XtcpFlatRecord::set_allocated_enrich_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[1], 0x00000100U); + } else { + ClearHasBit(_impl_._has_bits_[1], 0x00000100U); + } + _impl_.enrich_socket_dest_network_owner_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.enrich_socket_dest_network_owner_.IsDefault()) { + _impl_.enrich_socket_dest_network_owner_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_network_owner) +} + +// uint32 inet_diag_msg_family = 1001 [json_name = "inetDiagMsgFamily"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_family() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_family_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00200000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_family() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) + return _internal_inet_diag_msg_family(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_family(::uint32_t value) { + _internal_set_inet_diag_msg_family(value); + SetHasBit(_impl_._has_bits_[1], 0x00200000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_family) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_family() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_family_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_family(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_family_ = value; +} + +// uint32 inet_diag_msg_state = 1002 [json_name = "inetDiagMsgState"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_state() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_state_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00400000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_state() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) + return _internal_inet_diag_msg_state(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_state(::uint32_t value) { + _internal_set_inet_diag_msg_state(value); + SetHasBit(_impl_._has_bits_[1], 0x00400000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_state) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_state() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_state_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_state(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_state_ = value; +} + +// uint32 inet_diag_msg_timer = 1003 [json_name = "inetDiagMsgTimer"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_timer() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_timer_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x00800000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_timer() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) + return _internal_inet_diag_msg_timer(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_timer(::uint32_t value) { + _internal_set_inet_diag_msg_timer(value); + SetHasBit(_impl_._has_bits_[1], 0x00800000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_timer) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_timer() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_timer_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_timer(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_timer_ = value; +} + +// uint32 inet_diag_msg_retrans = 1004 [json_name = "inetDiagMsgRetrans"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_retrans() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_retrans_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x01000000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_retrans() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) + return _internal_inet_diag_msg_retrans(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_retrans(::uint32_t value) { + _internal_set_inet_diag_msg_retrans(value); + SetHasBit(_impl_._has_bits_[1], 0x01000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_retrans) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_retrans() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_retrans_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_retrans(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_retrans_ = value; +} + +// uint32 inet_diag_msg_socket_source_port = 1005 [json_name = "inetDiagMsgSocketSourcePort"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_socket_source_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_source_port_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x02000000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_source_port() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) + return _internal_inet_diag_msg_socket_source_port(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_socket_source_port(::uint32_t value) { + _internal_set_inet_diag_msg_socket_source_port(value); + SetHasBit(_impl_._has_bits_[1], 0x02000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source_port) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_source_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_socket_source_port_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_source_port(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_source_port_ = value; +} + +// uint32 inet_diag_msg_socket_destination_port = 1006 [json_name = "inetDiagMsgSocketDestinationPort"]; +inline void XtcpFlatRecord::clear_inet_diag_msg_socket_destination_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_destination_port_ = 0u; + ClearHasBit(_impl_._has_bits_[1], 0x04000000U); +} +inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_destination_port() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) + return _internal_inet_diag_msg_socket_destination_port(); +} +inline void XtcpFlatRecord::set_inet_diag_msg_socket_destination_port(::uint32_t value) { + _internal_set_inet_diag_msg_socket_destination_port(value); + SetHasBit(_impl_._has_bits_[1], 0x04000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination_port) +} +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_destination_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.inet_diag_msg_socket_destination_port_; +} +inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_destination_port(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.inet_diag_msg_socket_destination_port_ = value; +} + +// bytes inet_diag_msg_socket_source = 1007 [json_name = "inetDiagMsgSocketSource"]; inline void XtcpFlatRecord::clear_inet_diag_msg_socket_source() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_source_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_source() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -5889,13 +6223,13 @@ inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_source() const template PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_inet_diag_msg_socket_source(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); _impl_.inet_diag_msg_socket_source_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source) } inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_inet_diag_msg_socket_source() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); ::std::string* _s = _internal_mutable_inet_diag_msg_socket_source(); // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source) return _s; @@ -5915,10 +6249,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_inet_di inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_socket_source() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_source) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000040U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000200U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); auto* released = _impl_.inet_diag_msg_socket_source_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.inet_diag_msg_socket_source_.Set("", GetArena()); @@ -5928,9 +6262,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_so inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_source(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000040U); + SetHasBit(_impl_._has_bits_[1], 0x00000200U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000040U); + ClearHasBit(_impl_._has_bits_[1], 0x00000200U); } _impl_.inet_diag_msg_socket_source_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inet_diag_msg_socket_source_.IsDefault()) { @@ -5943,7 +6277,7 @@ inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_source(::std::str inline void XtcpFlatRecord::clear_inet_diag_msg_socket_destination() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_destination_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_destination() const ABSL_ATTRIBUTE_LIFETIME_BOUND { @@ -5953,13 +6287,13 @@ inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_destination() c template PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_inet_diag_msg_socket_destination(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); _impl_.inet_diag_msg_socket_destination_.SetBytes(static_cast(arg), args..., GetArena()); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination) } inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_inet_diag_msg_socket_destination() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); ::std::string* _s = _internal_mutable_inet_diag_msg_socket_destination(); // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination) return _s; @@ -5979,10 +6313,10 @@ inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_inet_di inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_socket_destination() { ::google::protobuf::internal::TSanWrite(&_impl_); // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_destination) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000080U)) { + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000400U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); auto* released = _impl_.inet_diag_msg_socket_destination_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { _impl_.inet_diag_msg_socket_destination_.Set("", GetArena()); @@ -5992,9 +6326,9 @@ inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_so inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_destination(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000080U); + SetHasBit(_impl_._has_bits_[1], 0x00000400U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000080U); + ClearHasBit(_impl_._has_bits_[1], 0x00000400U); } _impl_.inet_diag_msg_socket_destination_.SetAllocated(value, GetArena()); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inet_diag_msg_socket_destination_.IsDefault()) { @@ -6007,7 +6341,7 @@ inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_destination(::std inline void XtcpFlatRecord::clear_inet_diag_msg_socket_interface() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_interface_ = 0u; - ClearHasBit(_impl_._has_bits_[0], 0x00040000U); + ClearHasBit(_impl_._has_bits_[1], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_interface() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_interface) @@ -6015,7 +6349,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_socket_interface() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_interface(::uint32_t value) { _internal_set_inet_diag_msg_socket_interface(value); - SetHasBit(_impl_._has_bits_[0], 0x00040000U); + SetHasBit(_impl_._has_bits_[1], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_interface) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_socket_interface() const { @@ -6031,7 +6365,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_interface(::uint3 inline void XtcpFlatRecord::clear_inet_diag_msg_socket_cookie() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_socket_cookie_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x00800000U); + ClearHasBit(_impl_._has_bits_[1], 0x10000000U); } inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_cookie() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_cookie) @@ -6039,7 +6373,7 @@ inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_cookie() const { } inline void XtcpFlatRecord::set_inet_diag_msg_socket_cookie(::uint64_t value) { _internal_set_inet_diag_msg_socket_cookie(value); - SetHasBit(_impl_._has_bits_[1], 0x00800000U); + SetHasBit(_impl_._has_bits_[1], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_cookie) } inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_cookie() const { @@ -6051,59 +6385,11 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_cookie(::uint64_t _impl_.inet_diag_msg_socket_cookie_ = value; } -// uint64 inet_diag_msg_socket_dest_asn = 1011 [json_name = "inetDiagMsgSocketDestAsn"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_asn() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_asn_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x01000000U); -} -inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_dest_asn() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_asn) - return _internal_inet_diag_msg_socket_dest_asn(); -} -inline void XtcpFlatRecord::set_inet_diag_msg_socket_dest_asn(::uint64_t value) { - _internal_set_inet_diag_msg_socket_dest_asn(value); - SetHasBit(_impl_._has_bits_[1], 0x01000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_asn) -} -inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_asn() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_socket_dest_asn_; -} -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_asn(::uint64_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_asn_ = value; -} - -// uint64 inet_diag_msg_socket_next_hop_asn = 1012 [json_name = "inetDiagMsgSocketNextHopAsn"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_next_hop_asn() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_next_hop_asn_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[1], 0x02000000U); -} -inline ::uint64_t XtcpFlatRecord::inet_diag_msg_socket_next_hop_asn() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_next_hop_asn) - return _internal_inet_diag_msg_socket_next_hop_asn(); -} -inline void XtcpFlatRecord::set_inet_diag_msg_socket_next_hop_asn(::uint64_t value) { - _internal_set_inet_diag_msg_socket_next_hop_asn(value); - SetHasBit(_impl_._has_bits_[1], 0x02000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_next_hop_asn) -} -inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_msg_socket_next_hop_asn() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_socket_next_hop_asn_; -} -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_next_hop_asn(::uint64_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_next_hop_asn_ = value; -} - // uint32 inet_diag_msg_expires = 1013 [json_name = "inetDiagMsgExpires"]; inline void XtcpFlatRecord::clear_inet_diag_msg_expires() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_expires_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x00400000U); + ClearHasBit(_impl_._has_bits_[1], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_expires() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_expires) @@ -6111,7 +6397,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_expires() const { } inline void XtcpFlatRecord::set_inet_diag_msg_expires(::uint32_t value) { _internal_set_inet_diag_msg_expires(value); - SetHasBit(_impl_._has_bits_[1], 0x00400000U); + SetHasBit(_impl_._has_bits_[1], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_expires) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_expires() const { @@ -6127,7 +6413,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_expires(::uint32_t value inline void XtcpFlatRecord::clear_inet_diag_msg_rqueue() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_rqueue_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x04000000U); + ClearHasBit(_impl_._has_bits_[1], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_rqueue() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_rqueue) @@ -6135,7 +6421,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_rqueue() const { } inline void XtcpFlatRecord::set_inet_diag_msg_rqueue(::uint32_t value) { _internal_set_inet_diag_msg_rqueue(value); - SetHasBit(_impl_._has_bits_[1], 0x04000000U); + SetHasBit(_impl_._has_bits_[1], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_rqueue) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_rqueue() const { @@ -6151,7 +6437,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_rqueue(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_wqueue() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_wqueue_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x08000000U); + ClearHasBit(_impl_._has_bits_[1], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_wqueue() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_wqueue) @@ -6159,7 +6445,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_wqueue() const { } inline void XtcpFlatRecord::set_inet_diag_msg_wqueue(::uint32_t value) { _internal_set_inet_diag_msg_wqueue(value); - SetHasBit(_impl_._has_bits_[1], 0x08000000U); + SetHasBit(_impl_._has_bits_[1], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_wqueue) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_wqueue() const { @@ -6175,7 +6461,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_wqueue(::uint32_t value) inline void XtcpFlatRecord::clear_inet_diag_msg_uid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_uid_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x10000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_uid() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_uid) @@ -6183,7 +6469,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_uid() const { } inline void XtcpFlatRecord::set_inet_diag_msg_uid(::uint32_t value) { _internal_set_inet_diag_msg_uid(value); - SetHasBit(_impl_._has_bits_[1], 0x10000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_uid) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_uid() const { @@ -6199,7 +6485,7 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_uid(::uint32_t value) { inline void XtcpFlatRecord::clear_inet_diag_msg_inode() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.inet_diag_msg_inode_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x20000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::inet_diag_msg_inode() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_inode) @@ -6207,7 +6493,7 @@ inline ::uint32_t XtcpFlatRecord::inet_diag_msg_inode() const { } inline void XtcpFlatRecord::set_inet_diag_msg_inode(::uint32_t value) { _internal_set_inet_diag_msg_inode(value); - SetHasBit(_impl_._has_bits_[1], 0x20000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_inode) } inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_msg_inode() const { @@ -6219,99 +6505,11 @@ inline void XtcpFlatRecord::_internal_set_inet_diag_msg_inode(::uint32_t value) _impl_.inet_diag_msg_inode_ = value; } -// string inet_diag_msg_socket_dest_network_owner = 1018 [json_name = "inetDiagMsgSocketDestNetworkOwner"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_network_owner() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_network_owner_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); -} -inline const ::std::string& XtcpFlatRecord::inet_diag_msg_socket_dest_network_owner() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) - return _internal_inet_diag_msg_socket_dest_network_owner(); -} -template -PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_inet_diag_msg_socket_dest_network_owner(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000100U); - _impl_.inet_diag_msg_socket_dest_network_owner_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) -} -inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_inet_diag_msg_socket_dest_network_owner() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); - ::std::string* _s = _internal_mutable_inet_diag_msg_socket_dest_network_owner(); - // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) - return _s; -} -inline const ::std::string& XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_network_owner() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.inet_diag_msg_socket_dest_network_owner_.Get(); -} -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_network_owner(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_network_owner_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_inet_diag_msg_socket_dest_network_owner() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.inet_diag_msg_socket_dest_network_owner_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_msg_socket_dest_network_owner() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000100U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); - auto* released = _impl_.inet_diag_msg_socket_dest_network_owner_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.inet_diag_msg_socket_dest_network_owner_.Set("", GetArena()); - } - return released; -} -inline void XtcpFlatRecord::set_allocated_inet_diag_msg_socket_dest_network_owner(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000100U); - } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000100U); - } - _impl_.inet_diag_msg_socket_dest_network_owner_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inet_diag_msg_socket_dest_network_owner_.IsDefault()) { - _impl_.inet_diag_msg_socket_dest_network_owner_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_network_owner) -} - -// .xtcp_flat_record.v1.XtcpFlatRecord.Locality inet_diag_msg_socket_dest_locality = 1019 [json_name = "inetDiagMsgSocketDestLocality"]; -inline void XtcpFlatRecord::clear_inet_diag_msg_socket_dest_locality() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_locality_ = 0; - ClearHasBit(_impl_._has_bits_[1], 0x40000000U); -} -inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::inet_diag_msg_socket_dest_locality() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality) - return _internal_inet_diag_msg_socket_dest_locality(); -} -inline void XtcpFlatRecord::set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { - _internal_set_inet_diag_msg_socket_dest_locality(value); - SetHasBit(_impl_._has_bits_[1], 0x40000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality) -} -inline ::xtcp_flat_record::v1::XtcpFlatRecord_Locality XtcpFlatRecord::_internal_inet_diag_msg_socket_dest_locality() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::xtcp_flat_record::v1::XtcpFlatRecord_Locality>(_impl_.inet_diag_msg_socket_dest_locality_); -} -inline void XtcpFlatRecord::_internal_set_inet_diag_msg_socket_dest_locality(::xtcp_flat_record::v1::XtcpFlatRecord_Locality value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.inet_diag_msg_socket_dest_locality_ = value; -} - // uint32 mem_info_rmem = 1101 [json_name = "memInfoRmem"]; inline void XtcpFlatRecord::clear_mem_info_rmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_rmem_ = 0u; - ClearHasBit(_impl_._has_bits_[1], 0x80000000U); + ClearHasBit(_impl_._has_bits_[2], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) @@ -6319,7 +6517,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_rmem() const { } inline void XtcpFlatRecord::set_mem_info_rmem(::uint32_t value) { _internal_set_mem_info_rmem(value); - SetHasBit(_impl_._has_bits_[1], 0x80000000U); + SetHasBit(_impl_._has_bits_[2], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_rmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_rmem() const { @@ -6335,7 +6533,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_rmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_wmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_wmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000001U); + ClearHasBit(_impl_._has_bits_[2], 0x00000008U); } inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) @@ -6343,7 +6541,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_wmem() const { } inline void XtcpFlatRecord::set_mem_info_wmem(::uint32_t value) { _internal_set_mem_info_wmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000001U); + SetHasBit(_impl_._has_bits_[2], 0x00000008U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_wmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_wmem() const { @@ -6359,7 +6557,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_wmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_fmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_fmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000002U); + ClearHasBit(_impl_._has_bits_[2], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) @@ -6367,7 +6565,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_fmem() const { } inline void XtcpFlatRecord::set_mem_info_fmem(::uint32_t value) { _internal_set_mem_info_fmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000002U); + SetHasBit(_impl_._has_bits_[2], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_fmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_fmem() const { @@ -6383,7 +6581,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_fmem(::uint32_t value) { inline void XtcpFlatRecord::clear_mem_info_tmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.mem_info_tmem_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000004U); + ClearHasBit(_impl_._has_bits_[2], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) @@ -6391,7 +6589,7 @@ inline ::uint32_t XtcpFlatRecord::mem_info_tmem() const { } inline void XtcpFlatRecord::set_mem_info_tmem(::uint32_t value) { _internal_set_mem_info_tmem(value); - SetHasBit(_impl_._has_bits_[2], 0x00000004U); + SetHasBit(_impl_._has_bits_[2], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.mem_info_tmem) } inline ::uint32_t XtcpFlatRecord::_internal_mem_info_tmem() const { @@ -6407,7 +6605,7 @@ inline void XtcpFlatRecord::_internal_set_mem_info_tmem(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000008U); + ClearHasBit(_impl_._has_bits_[2], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) @@ -6415,7 +6613,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_state() const { } inline void XtcpFlatRecord::set_tcp_info_state(::uint32_t value) { _internal_set_tcp_info_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000008U); + SetHasBit(_impl_._has_bits_[2], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_state() const { @@ -6431,7 +6629,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ca_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ca_state_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000010U); + ClearHasBit(_impl_._has_bits_[2], 0x00000080U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) @@ -6439,7 +6637,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ca_state() const { } inline void XtcpFlatRecord::set_tcp_info_ca_state(::uint32_t value) { _internal_set_tcp_info_ca_state(value); - SetHasBit(_impl_._has_bits_[2], 0x00000010U); + SetHasBit(_impl_._has_bits_[2], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ca_state) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ca_state() const { @@ -6455,7 +6653,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ca_state(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retransmits() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retransmits_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000020U); + ClearHasBit(_impl_._has_bits_[2], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) @@ -6463,7 +6661,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retransmits() const { } inline void XtcpFlatRecord::set_tcp_info_retransmits(::uint32_t value) { _internal_set_tcp_info_retransmits(value); - SetHasBit(_impl_._has_bits_[2], 0x00000020U); + SetHasBit(_impl_._has_bits_[2], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retransmits) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retransmits() const { @@ -6479,7 +6677,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retransmits(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_probes() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_probes_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000040U); + ClearHasBit(_impl_._has_bits_[2], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) @@ -6487,7 +6685,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_probes() const { } inline void XtcpFlatRecord::set_tcp_info_probes(::uint32_t value) { _internal_set_tcp_info_probes(value); - SetHasBit(_impl_._has_bits_[2], 0x00000040U); + SetHasBit(_impl_._has_bits_[2], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_probes) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_probes() const { @@ -6503,7 +6701,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_probes(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_backoff() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_backoff_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000080U); + ClearHasBit(_impl_._has_bits_[2], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) @@ -6511,7 +6709,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_backoff() const { } inline void XtcpFlatRecord::set_tcp_info_backoff(::uint32_t value) { _internal_set_tcp_info_backoff(value); - SetHasBit(_impl_._has_bits_[2], 0x00000080U); + SetHasBit(_impl_._has_bits_[2], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_backoff) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_backoff() const { @@ -6527,7 +6725,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_backoff(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_options() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_options_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000100U); + ClearHasBit(_impl_._has_bits_[2], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) @@ -6535,7 +6733,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_options() const { } inline void XtcpFlatRecord::set_tcp_info_options(::uint32_t value) { _internal_set_tcp_info_options(value); - SetHasBit(_impl_._has_bits_[2], 0x00000100U); + SetHasBit(_impl_._has_bits_[2], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_options) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_options() const { @@ -6547,59 +6745,59 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_options(::uint32_t value) { _impl_.tcp_info_options_ = value; } -// uint32 tcp_info_send_scale = 1207 [json_name = "tcpInfoSendScale"]; -inline void XtcpFlatRecord::clear_tcp_info_send_scale() { +// uint32 tcp_info_snd_wscale = 1207 [json_name = "tcpInfoSndWscale"]; +inline void XtcpFlatRecord::clear_tcp_info_snd_wscale() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_send_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000200U); + _impl_.tcp_info_snd_wscale_ = 0u; + ClearHasBit(_impl_._has_bits_[2], 0x00001000U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_send_scale() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) - return _internal_tcp_info_send_scale(); +inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wscale() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wscale) + return _internal_tcp_info_snd_wscale(); } -inline void XtcpFlatRecord::set_tcp_info_send_scale(::uint32_t value) { - _internal_set_tcp_info_send_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000200U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_send_scale) +inline void XtcpFlatRecord::set_tcp_info_snd_wscale(::uint32_t value) { + _internal_set_tcp_info_snd_wscale(value); + SetHasBit(_impl_._has_bits_[2], 0x00001000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wscale) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_send_scale() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_wscale() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_send_scale_; + return _impl_.tcp_info_snd_wscale_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_send_scale(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_snd_wscale(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_send_scale_ = value; + _impl_.tcp_info_snd_wscale_ = value; } -// uint32 tcp_info_rcv_scale = 1208 [json_name = "tcpInfoRcvScale"]; -inline void XtcpFlatRecord::clear_tcp_info_rcv_scale() { +// uint32 tcp_info_rcv_wscale = 1208 [json_name = "tcpInfoRcvWscale"]; +inline void XtcpFlatRecord::clear_tcp_info_rcv_wscale() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_rcv_scale_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000400U); + _impl_.tcp_info_rcv_wscale_ = 0u; + ClearHasBit(_impl_._has_bits_[2], 0x00002000U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_scale() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) - return _internal_tcp_info_rcv_scale(); +inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wscale() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wscale) + return _internal_tcp_info_rcv_wscale(); } -inline void XtcpFlatRecord::set_tcp_info_rcv_scale(::uint32_t value) { - _internal_set_tcp_info_rcv_scale(value); - SetHasBit(_impl_._has_bits_[2], 0x00000400U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_scale) +inline void XtcpFlatRecord::set_tcp_info_rcv_wscale(::uint32_t value) { + _internal_set_tcp_info_rcv_wscale(value); + SetHasBit(_impl_._has_bits_[2], 0x00002000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wscale) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_scale() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_wscale() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_rcv_scale_; + return _impl_.tcp_info_rcv_wscale_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_scale(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_wscale(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_rcv_scale_ = value; + _impl_.tcp_info_rcv_wscale_ = value; } // uint32 tcp_info_delivery_rate_app_limited = 1209 [json_name = "tcpInfoDeliveryRateAppLimited"]; inline void XtcpFlatRecord::clear_tcp_info_delivery_rate_app_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivery_rate_app_limited_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00000800U); + ClearHasBit(_impl_._has_bits_[2], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) @@ -6607,7 +6805,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivery_rate_app_limited() const { } inline void XtcpFlatRecord::set_tcp_info_delivery_rate_app_limited(::uint32_t value) { _internal_set_tcp_info_delivery_rate_app_limited(value); - SetHasBit(_impl_._has_bits_[2], 0x00000800U); + SetHasBit(_impl_._has_bits_[2], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate_app_limited) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivery_rate_app_limited() const { @@ -6619,35 +6817,35 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivery_rate_app_limited(::u _impl_.tcp_info_delivery_rate_app_limited_ = value; } -// uint32 tcp_info_fast_open_client_failed = 1210 [json_name = "tcpInfoFastOpenClientFailed"]; -inline void XtcpFlatRecord::clear_tcp_info_fast_open_client_failed() { +// uint32 tcp_info_fastopen_client_fail = 1210 [json_name = "tcpInfoFastopenClientFail"]; +inline void XtcpFlatRecord::clear_tcp_info_fastopen_client_fail() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_fast_open_client_failed_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00001000U); + _impl_.tcp_info_fastopen_client_fail_ = 0u; + ClearHasBit(_impl_._has_bits_[2], 0x00008000U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_fast_open_client_failed() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) - return _internal_tcp_info_fast_open_client_failed(); +inline ::uint32_t XtcpFlatRecord::tcp_info_fastopen_client_fail() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fastopen_client_fail) + return _internal_tcp_info_fastopen_client_fail(); } -inline void XtcpFlatRecord::set_tcp_info_fast_open_client_failed(::uint32_t value) { - _internal_set_tcp_info_fast_open_client_failed(value); - SetHasBit(_impl_._has_bits_[2], 0x00001000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fast_open_client_failed) +inline void XtcpFlatRecord::set_tcp_info_fastopen_client_fail(::uint32_t value) { + _internal_set_tcp_info_fastopen_client_fail(value); + SetHasBit(_impl_._has_bits_[2], 0x00008000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fastopen_client_fail) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fast_open_client_failed() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fastopen_client_fail() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_fast_open_client_failed_; + return _impl_.tcp_info_fastopen_client_fail_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_fast_open_client_failed(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_fastopen_client_fail(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_fast_open_client_failed_ = value; + _impl_.tcp_info_fastopen_client_fail_ = value; } // uint32 tcp_info_rto = 1215 [json_name = "tcpInfoRto"]; inline void XtcpFlatRecord::clear_tcp_info_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00002000U); + ClearHasBit(_impl_._has_bits_[2], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) @@ -6655,7 +6853,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rto() const { } inline void XtcpFlatRecord::set_tcp_info_rto(::uint32_t value) { _internal_set_tcp_info_rto(value); - SetHasBit(_impl_._has_bits_[2], 0x00002000U); + SetHasBit(_impl_._has_bits_[2], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rto() const { @@ -6671,7 +6869,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_ato() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_ato_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00004000U); + ClearHasBit(_impl_._has_bits_[2], 0x00020000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) @@ -6679,7 +6877,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_ato() const { } inline void XtcpFlatRecord::set_tcp_info_ato(::uint32_t value) { _internal_set_tcp_info_ato(value); - SetHasBit(_impl_._has_bits_[2], 0x00004000U); + SetHasBit(_impl_._has_bits_[2], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_ato) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_ato() const { @@ -6695,7 +6893,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_ato(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_snd_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00008000U); + ClearHasBit(_impl_._has_bits_[2], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) @@ -6703,7 +6901,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_mss() const { } inline void XtcpFlatRecord::set_tcp_info_snd_mss(::uint32_t value) { _internal_set_tcp_info_snd_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00008000U); + SetHasBit(_impl_._has_bits_[2], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_mss() const { @@ -6719,7 +6917,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_mss() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00010000U); + ClearHasBit(_impl_._has_bits_[2], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) @@ -6727,7 +6925,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_mss() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_mss(::uint32_t value) { _internal_set_tcp_info_rcv_mss(value); - SetHasBit(_impl_._has_bits_[2], 0x00010000U); + SetHasBit(_impl_._has_bits_[2], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_mss) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_mss() const { @@ -6743,7 +6941,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_mss(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_unacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_unacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00020000U); + ClearHasBit(_impl_._has_bits_[2], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) @@ -6751,7 +6949,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_unacked() const { } inline void XtcpFlatRecord::set_tcp_info_unacked(::uint32_t value) { _internal_set_tcp_info_unacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00020000U); + SetHasBit(_impl_._has_bits_[2], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_unacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_unacked() const { @@ -6767,7 +6965,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_unacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_sacked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sacked_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00040000U); + ClearHasBit(_impl_._has_bits_[2], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) @@ -6775,7 +6973,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_sacked() const { } inline void XtcpFlatRecord::set_tcp_info_sacked(::uint32_t value) { _internal_set_tcp_info_sacked(value); - SetHasBit(_impl_._has_bits_[2], 0x00040000U); + SetHasBit(_impl_._has_bits_[2], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sacked) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_sacked() const { @@ -6791,7 +6989,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sacked(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_lost() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_lost_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00080000U); + ClearHasBit(_impl_._has_bits_[2], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) @@ -6799,7 +6997,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_lost() const { } inline void XtcpFlatRecord::set_tcp_info_lost(::uint32_t value) { _internal_set_tcp_info_lost(value); - SetHasBit(_impl_._has_bits_[2], 0x00080000U); + SetHasBit(_impl_._has_bits_[2], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_lost) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_lost() const { @@ -6815,7 +7013,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_lost(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00100000U); + ClearHasBit(_impl_._has_bits_[2], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) @@ -6823,7 +7021,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_retrans(::uint32_t value) { _internal_set_tcp_info_retrans(value); - SetHasBit(_impl_._has_bits_[2], 0x00100000U); + SetHasBit(_impl_._has_bits_[2], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_retrans() const { @@ -6839,7 +7037,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_retrans(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_fackets() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_fackets_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00200000U); + ClearHasBit(_impl_._has_bits_[2], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) @@ -6847,7 +7045,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_fackets() const { } inline void XtcpFlatRecord::set_tcp_info_fackets(::uint32_t value) { _internal_set_tcp_info_fackets(value); - SetHasBit(_impl_._has_bits_[2], 0x00200000U); + SetHasBit(_impl_._has_bits_[2], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_fackets) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_fackets() const { @@ -6863,7 +7061,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_fackets(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_last_data_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00400000U); + ClearHasBit(_impl_._has_bits_[2], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) @@ -6871,7 +7069,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_sent(::uint32_t value) { _internal_set_tcp_info_last_data_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00400000U); + SetHasBit(_impl_._has_bits_[2], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_sent() const { @@ -6887,7 +7085,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_sent(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_sent_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x00800000U); + ClearHasBit(_impl_._has_bits_[2], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) @@ -6895,7 +7093,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_sent() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_sent(::uint32_t value) { _internal_set_tcp_info_last_ack_sent(value); - SetHasBit(_impl_._has_bits_[2], 0x00800000U); + SetHasBit(_impl_._has_bits_[2], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_sent) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_sent() const { @@ -6911,7 +7109,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_sent(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_last_data_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_data_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x01000000U); + ClearHasBit(_impl_._has_bits_[2], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) @@ -6919,7 +7117,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_data_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_data_recv(::uint32_t value) { _internal_set_tcp_info_last_data_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x01000000U); + SetHasBit(_impl_._has_bits_[2], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_data_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_data_recv() const { @@ -6935,7 +7133,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_data_recv(::uint32_t val inline void XtcpFlatRecord::clear_tcp_info_last_ack_recv() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_last_ack_recv_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x02000000U); + ClearHasBit(_impl_._has_bits_[2], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) @@ -6943,7 +7141,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_last_ack_recv() const { } inline void XtcpFlatRecord::set_tcp_info_last_ack_recv(::uint32_t value) { _internal_set_tcp_info_last_ack_recv(value); - SetHasBit(_impl_._has_bits_[2], 0x02000000U); + SetHasBit(_impl_._has_bits_[2], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_last_ack_recv) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_last_ack_recv() const { @@ -6959,7 +7157,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_last_ack_recv(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_pmtu() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_pmtu_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x04000000U); + ClearHasBit(_impl_._has_bits_[2], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) @@ -6967,7 +7165,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_pmtu() const { } inline void XtcpFlatRecord::set_tcp_info_pmtu(::uint32_t value) { _internal_set_tcp_info_pmtu(value); - SetHasBit(_impl_._has_bits_[2], 0x04000000U); + SetHasBit(_impl_._has_bits_[2], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pmtu) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_pmtu() const { @@ -6983,7 +7181,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_pmtu(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x08000000U); + ClearHasBit(_impl_._has_bits_[2], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) @@ -6991,7 +7189,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ssthresh(::uint32_t value) { _internal_set_tcp_info_rcv_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x08000000U); + SetHasBit(_impl_._has_bits_[2], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ssthresh() const { @@ -7007,7 +7205,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x10000000U); + ClearHasBit(_impl_._has_bits_[2], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) @@ -7015,7 +7213,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rtt(::uint32_t value) { _internal_set_tcp_info_rtt(value); - SetHasBit(_impl_._has_bits_[2], 0x10000000U); + SetHasBit(_impl_._has_bits_[2], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt() const { @@ -7027,35 +7225,35 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rtt(::uint32_t value) { _impl_.tcp_info_rtt_ = value; } -// uint32 tcp_info_rtt_var = 1231 [json_name = "tcpInfoRttVar"]; -inline void XtcpFlatRecord::clear_tcp_info_rtt_var() { +// uint32 tcp_info_rttvar = 1231 [json_name = "tcpInfoRttvar"]; +inline void XtcpFlatRecord::clear_tcp_info_rttvar() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_rtt_var_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x20000000U); + _impl_.tcp_info_rttvar_ = 0u; + ClearHasBit(_impl_._has_bits_[3], 0x00000001U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_rtt_var() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) - return _internal_tcp_info_rtt_var(); +inline ::uint32_t XtcpFlatRecord::tcp_info_rttvar() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rttvar) + return _internal_tcp_info_rttvar(); } -inline void XtcpFlatRecord::set_tcp_info_rtt_var(::uint32_t value) { - _internal_set_tcp_info_rtt_var(value); - SetHasBit(_impl_._has_bits_[2], 0x20000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rtt_var) +inline void XtcpFlatRecord::set_tcp_info_rttvar(::uint32_t value) { + _internal_set_tcp_info_rttvar(value); + SetHasBit(_impl_._has_bits_[3], 0x00000001U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rttvar) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rtt_var() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rttvar() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_rtt_var_; + return _impl_.tcp_info_rttvar_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_rtt_var(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_rttvar(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_rtt_var_ = value; + _impl_.tcp_info_rttvar_ = value; } // uint32 tcp_info_snd_ssthresh = 1232 [json_name = "tcpInfoSndSsthresh"]; inline void XtcpFlatRecord::clear_tcp_info_snd_ssthresh() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_ssthresh_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x40000000U); + ClearHasBit(_impl_._has_bits_[3], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) @@ -7063,7 +7261,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_ssthresh() const { } inline void XtcpFlatRecord::set_tcp_info_snd_ssthresh(::uint32_t value) { _internal_set_tcp_info_snd_ssthresh(value); - SetHasBit(_impl_._has_bits_[2], 0x40000000U); + SetHasBit(_impl_._has_bits_[3], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_ssthresh) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_ssthresh() const { @@ -7079,7 +7277,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_ssthresh(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_snd_cwnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_cwnd_ = 0u; - ClearHasBit(_impl_._has_bits_[2], 0x80000000U); + ClearHasBit(_impl_._has_bits_[3], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) @@ -7087,7 +7285,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_cwnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_cwnd(::uint32_t value) { _internal_set_tcp_info_snd_cwnd(value); - SetHasBit(_impl_._has_bits_[2], 0x80000000U); + SetHasBit(_impl_._has_bits_[3], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_cwnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_cwnd() const { @@ -7099,35 +7297,35 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_cwnd(::uint32_t value) { _impl_.tcp_info_snd_cwnd_ = value; } -// uint32 tcp_info_adv_mss = 1234 [json_name = "tcpInfoAdvMss"]; -inline void XtcpFlatRecord::clear_tcp_info_adv_mss() { +// uint32 tcp_info_advmss = 1234 [json_name = "tcpInfoAdvmss"]; +inline void XtcpFlatRecord::clear_tcp_info_advmss() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_adv_mss_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000001U); + _impl_.tcp_info_advmss_ = 0u; + ClearHasBit(_impl_._has_bits_[3], 0x00000008U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_adv_mss() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) - return _internal_tcp_info_adv_mss(); +inline ::uint32_t XtcpFlatRecord::tcp_info_advmss() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_advmss) + return _internal_tcp_info_advmss(); } -inline void XtcpFlatRecord::set_tcp_info_adv_mss(::uint32_t value) { - _internal_set_tcp_info_adv_mss(value); - SetHasBit(_impl_._has_bits_[3], 0x00000001U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_adv_mss) +inline void XtcpFlatRecord::set_tcp_info_advmss(::uint32_t value) { + _internal_set_tcp_info_advmss(value); + SetHasBit(_impl_._has_bits_[3], 0x00000008U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_advmss) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_adv_mss() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_advmss() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_adv_mss_; + return _impl_.tcp_info_advmss_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_adv_mss(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_advmss(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_adv_mss_ = value; + _impl_.tcp_info_advmss_ = value; } // uint32 tcp_info_reordering = 1235 [json_name = "tcpInfoReordering"]; inline void XtcpFlatRecord::clear_tcp_info_reordering() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reordering_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000002U); + ClearHasBit(_impl_._has_bits_[3], 0x00000010U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) @@ -7135,7 +7333,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reordering() const { } inline void XtcpFlatRecord::set_tcp_info_reordering(::uint32_t value) { _internal_set_tcp_info_reordering(value); - SetHasBit(_impl_._has_bits_[3], 0x00000002U); + SetHasBit(_impl_._has_bits_[3], 0x00000010U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reordering) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reordering() const { @@ -7151,7 +7349,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reordering(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000004U); + ClearHasBit(_impl_._has_bits_[3], 0x00000020U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) @@ -7159,7 +7357,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_rtt(::uint32_t value) { _internal_set_tcp_info_rcv_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00000004U); + SetHasBit(_impl_._has_bits_[3], 0x00000020U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_rtt() const { @@ -7175,7 +7373,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_space() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_space_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000008U); + ClearHasBit(_impl_._has_bits_[3], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) @@ -7183,7 +7381,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_space() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_space(::uint32_t value) { _internal_set_tcp_info_rcv_space(value); - SetHasBit(_impl_._has_bits_[3], 0x00000008U); + SetHasBit(_impl_._has_bits_[3], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_space) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_space() const { @@ -7199,7 +7397,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_space(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_retrans_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000040U); + ClearHasBit(_impl_._has_bits_[3], 0x00000200U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) @@ -7207,7 +7405,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_total_retrans(::uint32_t value) { _internal_set_tcp_info_total_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00000040U); + SetHasBit(_impl_._has_bits_[3], 0x00000200U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_retrans) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_retrans() const { @@ -7223,7 +7421,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_retrans(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_pacing_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_pacing_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000010U); + ClearHasBit(_impl_._has_bits_[3], 0x00000080U); } inline ::uint64_t XtcpFlatRecord::tcp_info_pacing_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pacing_rate) @@ -7231,7 +7429,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_pacing_rate() const { } inline void XtcpFlatRecord::set_tcp_info_pacing_rate(::uint64_t value) { _internal_set_tcp_info_pacing_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00000010U); + SetHasBit(_impl_._has_bits_[3], 0x00000080U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_pacing_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_pacing_rate() const { @@ -7247,7 +7445,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_pacing_rate(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_max_pacing_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_max_pacing_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000020U); + ClearHasBit(_impl_._has_bits_[3], 0x00000100U); } inline ::uint64_t XtcpFlatRecord::tcp_info_max_pacing_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_max_pacing_rate) @@ -7255,7 +7453,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_max_pacing_rate() const { } inline void XtcpFlatRecord::set_tcp_info_max_pacing_rate(::uint64_t value) { _internal_set_tcp_info_max_pacing_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00000020U); + SetHasBit(_impl_._has_bits_[3], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_max_pacing_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_max_pacing_rate() const { @@ -7271,7 +7469,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_max_pacing_rate(::uint64_t va inline void XtcpFlatRecord::clear_tcp_info_bytes_acked() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_acked_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000100U); + ClearHasBit(_impl_._has_bits_[3], 0x00000800U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) @@ -7279,7 +7477,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_acked() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_acked(::uint64_t value) { _internal_set_tcp_info_bytes_acked(value); - SetHasBit(_impl_._has_bits_[3], 0x00000100U); + SetHasBit(_impl_._has_bits_[3], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_acked) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_acked() const { @@ -7295,7 +7493,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_acked(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_received() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_received_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00000200U); + ClearHasBit(_impl_._has_bits_[3], 0x00001000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) @@ -7303,7 +7501,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_received() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_received(::uint64_t value) { _internal_set_tcp_info_bytes_received(value); - SetHasBit(_impl_._has_bits_[3], 0x00000200U); + SetHasBit(_impl_._has_bits_[3], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_received) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_received() const { @@ -7319,7 +7517,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_received(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000080U); + ClearHasBit(_impl_._has_bits_[3], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) @@ -7327,7 +7525,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_segs_out(::uint32_t value) { _internal_set_tcp_info_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00000080U); + SetHasBit(_impl_._has_bits_[3], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_out() const { @@ -7343,7 +7541,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_out(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000400U); + ClearHasBit(_impl_._has_bits_[3], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) @@ -7351,7 +7549,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_segs_in(::uint32_t value) { _internal_set_tcp_info_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00000400U); + SetHasBit(_impl_._has_bits_[3], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_segs_in() const { @@ -7363,35 +7561,35 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_segs_in(::uint32_t value) { _impl_.tcp_info_segs_in_ = value; } -// uint32 tcp_info_not_sent_bytes = 1245 [json_name = "tcpInfoNotSentBytes"]; -inline void XtcpFlatRecord::clear_tcp_info_not_sent_bytes() { +// uint32 tcp_info_notsent_bytes = 1245 [json_name = "tcpInfoNotsentBytes"]; +inline void XtcpFlatRecord::clear_tcp_info_notsent_bytes() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_not_sent_bytes_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00000800U); + _impl_.tcp_info_notsent_bytes_ = 0u; + ClearHasBit(_impl_._has_bits_[3], 0x00004000U); } -inline ::uint32_t XtcpFlatRecord::tcp_info_not_sent_bytes() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) - return _internal_tcp_info_not_sent_bytes(); +inline ::uint32_t XtcpFlatRecord::tcp_info_notsent_bytes() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_notsent_bytes) + return _internal_tcp_info_notsent_bytes(); } -inline void XtcpFlatRecord::set_tcp_info_not_sent_bytes(::uint32_t value) { - _internal_set_tcp_info_not_sent_bytes(value); - SetHasBit(_impl_._has_bits_[3], 0x00000800U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_not_sent_bytes) +inline void XtcpFlatRecord::set_tcp_info_notsent_bytes(::uint32_t value) { + _internal_set_tcp_info_notsent_bytes(value); + SetHasBit(_impl_._has_bits_[3], 0x00004000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_notsent_bytes) } -inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_not_sent_bytes() const { +inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_notsent_bytes() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.tcp_info_not_sent_bytes_; + return _impl_.tcp_info_notsent_bytes_; } -inline void XtcpFlatRecord::_internal_set_tcp_info_not_sent_bytes(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_tcp_info_notsent_bytes(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.tcp_info_not_sent_bytes_ = value; + _impl_.tcp_info_notsent_bytes_ = value; } // uint32 tcp_info_min_rtt = 1246 [json_name = "tcpInfoMinRtt"]; inline void XtcpFlatRecord::clear_tcp_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00001000U); + ClearHasBit(_impl_._has_bits_[3], 0x00008000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) @@ -7399,7 +7597,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_min_rtt() const { } inline void XtcpFlatRecord::set_tcp_info_min_rtt(::uint32_t value) { _internal_set_tcp_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[3], 0x00001000U); + SetHasBit(_impl_._has_bits_[3], 0x00008000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_min_rtt() const { @@ -7415,7 +7613,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_data_segs_in() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_in_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00002000U); + ClearHasBit(_impl_._has_bits_[3], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) @@ -7423,7 +7621,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_in() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_in(::uint32_t value) { _internal_set_tcp_info_data_segs_in(value); - SetHasBit(_impl_._has_bits_[3], 0x00002000U); + SetHasBit(_impl_._has_bits_[3], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_in) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_in() const { @@ -7439,7 +7637,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_data_segs_in(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_data_segs_out() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_data_segs_out_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00010000U); + ClearHasBit(_impl_._has_bits_[3], 0x00080000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) @@ -7447,7 +7645,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_data_segs_out() const { } inline void XtcpFlatRecord::set_tcp_info_data_segs_out(::uint32_t value) { _internal_set_tcp_info_data_segs_out(value); - SetHasBit(_impl_._has_bits_[3], 0x00010000U); + SetHasBit(_impl_._has_bits_[3], 0x00080000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_data_segs_out) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_data_segs_out() const { @@ -7463,7 +7661,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_data_segs_out(::uint32_t valu inline void XtcpFlatRecord::clear_tcp_info_delivery_rate() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivery_rate_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00004000U); + ClearHasBit(_impl_._has_bits_[3], 0x00020000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_delivery_rate() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate) @@ -7471,7 +7669,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_delivery_rate() const { } inline void XtcpFlatRecord::set_tcp_info_delivery_rate(::uint64_t value) { _internal_set_tcp_info_delivery_rate(value); - SetHasBit(_impl_._has_bits_[3], 0x00004000U); + SetHasBit(_impl_._has_bits_[3], 0x00020000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivery_rate) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_delivery_rate() const { @@ -7487,7 +7685,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivery_rate(::uint64_t valu inline void XtcpFlatRecord::clear_tcp_info_busy_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_busy_time_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00008000U); + ClearHasBit(_impl_._has_bits_[3], 0x00040000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_busy_time() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_busy_time) @@ -7495,7 +7693,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_busy_time() const { } inline void XtcpFlatRecord::set_tcp_info_busy_time(::uint64_t value) { _internal_set_tcp_info_busy_time(value); - SetHasBit(_impl_._has_bits_[3], 0x00008000U); + SetHasBit(_impl_._has_bits_[3], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_busy_time) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_busy_time() const { @@ -7511,7 +7709,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_busy_time(::uint64_t value) { inline void XtcpFlatRecord::clear_tcp_info_rwnd_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rwnd_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00040000U); + ClearHasBit(_impl_._has_bits_[3], 0x00200000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) @@ -7519,7 +7717,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_rwnd_limited() const { } inline void XtcpFlatRecord::set_tcp_info_rwnd_limited(::uint64_t value) { _internal_set_tcp_info_rwnd_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00040000U); + SetHasBit(_impl_._has_bits_[3], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rwnd_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_rwnd_limited() const { @@ -7535,7 +7733,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rwnd_limited(::uint64_t value inline void XtcpFlatRecord::clear_tcp_info_sndbuf_limited() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_sndbuf_limited_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00080000U); + ClearHasBit(_impl_._has_bits_[3], 0x00400000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) @@ -7543,7 +7741,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_sndbuf_limited() const { } inline void XtcpFlatRecord::set_tcp_info_sndbuf_limited(::uint64_t value) { _internal_set_tcp_info_sndbuf_limited(value); - SetHasBit(_impl_._has_bits_[3], 0x00080000U); + SetHasBit(_impl_._has_bits_[3], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_sndbuf_limited) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_sndbuf_limited() const { @@ -7559,7 +7757,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_sndbuf_limited(::uint64_t val inline void XtcpFlatRecord::clear_tcp_info_delivered() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00020000U); + ClearHasBit(_impl_._has_bits_[3], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) @@ -7567,7 +7765,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered() const { } inline void XtcpFlatRecord::set_tcp_info_delivered(::uint32_t value) { _internal_set_tcp_info_delivered(value); - SetHasBit(_impl_._has_bits_[3], 0x00020000U); + SetHasBit(_impl_._has_bits_[3], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered() const { @@ -7583,7 +7781,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivered(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_delivered_ce() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_delivered_ce_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00200000U); + ClearHasBit(_impl_._has_bits_[3], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) @@ -7591,7 +7789,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_delivered_ce() const { } inline void XtcpFlatRecord::set_tcp_info_delivered_ce(::uint32_t value) { _internal_set_tcp_info_delivered_ce(value); - SetHasBit(_impl_._has_bits_[3], 0x00200000U); + SetHasBit(_impl_._has_bits_[3], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_delivered_ce) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_delivered_ce() const { @@ -7607,7 +7805,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_delivered_ce(::uint32_t value inline void XtcpFlatRecord::clear_tcp_info_bytes_sent() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_sent_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00100000U); + ClearHasBit(_impl_._has_bits_[3], 0x00800000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_sent() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_sent) @@ -7615,7 +7813,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_sent() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_sent(::uint64_t value) { _internal_set_tcp_info_bytes_sent(value); - SetHasBit(_impl_._has_bits_[3], 0x00100000U); + SetHasBit(_impl_._has_bits_[3], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_sent) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_sent() const { @@ -7631,7 +7829,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_sent(::uint64_t value) inline void XtcpFlatRecord::clear_tcp_info_bytes_retrans() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_bytes_retrans_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[3], 0x00800000U); + ClearHasBit(_impl_._has_bits_[3], 0x04000000U); } inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) @@ -7639,7 +7837,7 @@ inline ::uint64_t XtcpFlatRecord::tcp_info_bytes_retrans() const { } inline void XtcpFlatRecord::set_tcp_info_bytes_retrans(::uint64_t value) { _internal_set_tcp_info_bytes_retrans(value); - SetHasBit(_impl_._has_bits_[3], 0x00800000U); + SetHasBit(_impl_._has_bits_[3], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_bytes_retrans) } inline ::uint64_t XtcpFlatRecord::_internal_tcp_info_bytes_retrans() const { @@ -7655,7 +7853,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_bytes_retrans(::uint64_t valu inline void XtcpFlatRecord::clear_tcp_info_dsack_dups() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_dsack_dups_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x00400000U); + ClearHasBit(_impl_._has_bits_[3], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_dsack_dups() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_dsack_dups) @@ -7663,7 +7861,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_dsack_dups() const { } inline void XtcpFlatRecord::set_tcp_info_dsack_dups(::uint32_t value) { _internal_set_tcp_info_dsack_dups(value); - SetHasBit(_impl_._has_bits_[3], 0x00400000U); + SetHasBit(_impl_._has_bits_[3], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_dsack_dups) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_dsack_dups() const { @@ -7679,7 +7877,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_dsack_dups(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_reord_seen() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_reord_seen_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x01000000U); + ClearHasBit(_impl_._has_bits_[3], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) @@ -7687,7 +7885,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_reord_seen() const { } inline void XtcpFlatRecord::set_tcp_info_reord_seen(::uint32_t value) { _internal_set_tcp_info_reord_seen(value); - SetHasBit(_impl_._has_bits_[3], 0x01000000U); + SetHasBit(_impl_._has_bits_[3], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_reord_seen) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_reord_seen() const { @@ -7703,7 +7901,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_reord_seen(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_rcv_ooopack() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_ooopack_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x02000000U); + ClearHasBit(_impl_._has_bits_[3], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) @@ -7711,7 +7909,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_ooopack() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_ooopack(::uint32_t value) { _internal_set_tcp_info_rcv_ooopack(value); - SetHasBit(_impl_._has_bits_[3], 0x02000000U); + SetHasBit(_impl_._has_bits_[3], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_ooopack) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_ooopack() const { @@ -7727,7 +7925,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_ooopack(::uint32_t value) inline void XtcpFlatRecord::clear_tcp_info_snd_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_snd_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x04000000U); + ClearHasBit(_impl_._has_bits_[3], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) @@ -7735,7 +7933,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_snd_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_snd_wnd(::uint32_t value) { _internal_set_tcp_info_snd_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x04000000U); + SetHasBit(_impl_._has_bits_[3], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_snd_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_snd_wnd() const { @@ -7751,7 +7949,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_snd_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rcv_wnd() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rcv_wnd_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x08000000U); + ClearHasBit(_impl_._has_bits_[3], 0x40000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) @@ -7759,7 +7957,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rcv_wnd() const { } inline void XtcpFlatRecord::set_tcp_info_rcv_wnd(::uint32_t value) { _internal_set_tcp_info_rcv_wnd(value); - SetHasBit(_impl_._has_bits_[3], 0x08000000U); + SetHasBit(_impl_._has_bits_[3], 0x40000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rcv_wnd) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rcv_wnd() const { @@ -7775,7 +7973,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rcv_wnd(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_rehash() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_rehash_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x10000000U); + ClearHasBit(_impl_._has_bits_[3], 0x80000000U); } inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) @@ -7783,7 +7981,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_rehash() const { } inline void XtcpFlatRecord::set_tcp_info_rehash(::uint32_t value) { _internal_set_tcp_info_rehash(value); - SetHasBit(_impl_._has_bits_[3], 0x10000000U); + SetHasBit(_impl_._has_bits_[3], 0x80000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_rehash) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_rehash() const { @@ -7799,7 +7997,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_rehash(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x20000000U); + ClearHasBit(_impl_._has_bits_[4], 0x00000001U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) @@ -7807,7 +8005,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto(::uint32_t value) { _internal_set_tcp_info_total_rto(value); - SetHasBit(_impl_._has_bits_[3], 0x20000000U); + SetHasBit(_impl_._has_bits_[4], 0x00000001U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto() const { @@ -7823,7 +8021,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto(::uint32_t value) { inline void XtcpFlatRecord::clear_tcp_info_total_rto_recoveries() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_recoveries_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x40000000U); + ClearHasBit(_impl_._has_bits_[4], 0x00000002U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) @@ -7831,7 +8029,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_recoveries() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_recoveries(::uint32_t value) { _internal_set_tcp_info_total_rto_recoveries(value); - SetHasBit(_impl_._has_bits_[3], 0x40000000U); + SetHasBit(_impl_._has_bits_[4], 0x00000002U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_recoveries) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_recoveries() const { @@ -7847,7 +8045,7 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto_recoveries(::uint32 inline void XtcpFlatRecord::clear_tcp_info_total_rto_time() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.tcp_info_total_rto_time_ = 0u; - ClearHasBit(_impl_._has_bits_[3], 0x80000000U); + ClearHasBit(_impl_._has_bits_[4], 0x00000004U); } inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) @@ -7855,7 +8053,7 @@ inline ::uint32_t XtcpFlatRecord::tcp_info_total_rto_time() const { } inline void XtcpFlatRecord::set_tcp_info_total_rto_time(::uint32_t value) { _internal_set_tcp_info_total_rto_time(value); - SetHasBit(_impl_._has_bits_[3], 0x80000000U); + SetHasBit(_impl_._has_bits_[4], 0x00000004U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.tcp_info_total_rto_time) } inline ::uint32_t XtcpFlatRecord::_internal_tcp_info_total_rto_time() const { @@ -7867,147 +8065,147 @@ inline void XtcpFlatRecord::_internal_set_tcp_info_total_rto_time(::uint32_t val _impl_.tcp_info_total_rto_time_ = value; } -// string congestion_algorithm_string = 1300 [json_name = "congestionAlgorithmString"]; -inline void XtcpFlatRecord::clear_congestion_algorithm_string() { +// string inet_diag_cong = 1300 [json_name = "inetDiagCong"]; +inline void XtcpFlatRecord::clear_inet_diag_cong() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.congestion_algorithm_string_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + _impl_.inet_diag_cong_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } -inline const ::std::string& XtcpFlatRecord::congestion_algorithm_string() const +inline const ::std::string& XtcpFlatRecord::inet_diag_cong() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) - return _internal_congestion_algorithm_string(); + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong) + return _internal_inet_diag_cong(); } template -PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_congestion_algorithm_string(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void XtcpFlatRecord::set_inet_diag_cong(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[1], 0x00000200U); - _impl_.congestion_algorithm_string_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + _impl_.inet_diag_cong_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong) } -inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_congestion_algorithm_string() +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::mutable_inet_diag_cong() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); - ::std::string* _s = _internal_mutable_congestion_algorithm_string(); - // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) + SetHasBit(_impl_._has_bits_[1], 0x00000800U); + ::std::string* _s = _internal_mutable_inet_diag_cong(); + // @@protoc_insertion_point(field_mutable:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong) return _s; } -inline const ::std::string& XtcpFlatRecord::_internal_congestion_algorithm_string() const { +inline const ::std::string& XtcpFlatRecord::_internal_inet_diag_cong() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.congestion_algorithm_string_.Get(); + return _impl_.inet_diag_cong_.Get(); } -inline void XtcpFlatRecord::_internal_set_congestion_algorithm_string(const ::std::string& value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_cong(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.congestion_algorithm_string_.Set(value, GetArena()); + _impl_.inet_diag_cong_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_congestion_algorithm_string() { +inline ::std::string* PROTOBUF_NONNULL XtcpFlatRecord::_internal_mutable_inet_diag_cong() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.congestion_algorithm_string_.Mutable( GetArena()); + return _impl_.inet_diag_cong_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_congestion_algorithm_string() { +inline ::std::string* PROTOBUF_NULLABLE XtcpFlatRecord::release_inet_diag_cong() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) - if (!CheckHasBit(_impl_._has_bits_[1], 0x00000200U)) { + // @@protoc_insertion_point(field_release:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong) + if (!CheckHasBit(_impl_._has_bits_[1], 0x00000800U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); - auto* released = _impl_.congestion_algorithm_string_.Release(); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); + auto* released = _impl_.inet_diag_cong_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.congestion_algorithm_string_.Set("", GetArena()); + _impl_.inet_diag_cong_.Set("", GetArena()); } return released; } -inline void XtcpFlatRecord::set_allocated_congestion_algorithm_string(::std::string* PROTOBUF_NULLABLE value) { +inline void XtcpFlatRecord::set_allocated_inet_diag_cong(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[1], 0x00000200U); + SetHasBit(_impl_._has_bits_[1], 0x00000800U); } else { - ClearHasBit(_impl_._has_bits_[1], 0x00000200U); + ClearHasBit(_impl_._has_bits_[1], 0x00000800U); } - _impl_.congestion_algorithm_string_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.congestion_algorithm_string_.IsDefault()) { - _impl_.congestion_algorithm_string_.Set("", GetArena()); + _impl_.inet_diag_cong_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.inet_diag_cong_.IsDefault()) { + _impl_.inet_diag_cong_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_string) + // @@protoc_insertion_point(field_set_allocated:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong) } -// .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm congestion_algorithm_enum = 1301 [json_name = "congestionAlgorithmEnum"]; -inline void XtcpFlatRecord::clear_congestion_algorithm_enum() { +// .xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm inet_diag_cong_enum = 1301 [json_name = "inetDiagCongEnum"]; +inline void XtcpFlatRecord::clear_inet_diag_cong_enum() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.congestion_algorithm_enum_ = 0; - ClearHasBit(_impl_._has_bits_[4], 0x00000001U); + _impl_.inet_diag_cong_enum_ = 0; + ClearHasBit(_impl_._has_bits_[4], 0x00000008U); } -inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::congestion_algorithm_enum() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) - return _internal_congestion_algorithm_enum(); +inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::inet_diag_cong_enum() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong_enum) + return _internal_inet_diag_cong_enum(); } -inline void XtcpFlatRecord::set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { - _internal_set_congestion_algorithm_enum(value); - SetHasBit(_impl_._has_bits_[4], 0x00000001U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum) +inline void XtcpFlatRecord::set_inet_diag_cong_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { + _internal_set_inet_diag_cong_enum(value); + SetHasBit(_impl_._has_bits_[4], 0x00000008U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong_enum) } -inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::_internal_congestion_algorithm_enum() const { +inline ::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm XtcpFlatRecord::_internal_inet_diag_cong_enum() const { ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm>(_impl_.congestion_algorithm_enum_); + return static_cast<::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm>(_impl_.inet_diag_cong_enum_); } -inline void XtcpFlatRecord::_internal_set_congestion_algorithm_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_cong_enum(::xtcp_flat_record::v1::XtcpFlatRecord_CongestionAlgorithm value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.congestion_algorithm_enum_ = value; + _impl_.inet_diag_cong_enum_ = value; } -// uint32 type_of_service = 1401 [json_name = "typeOfService"]; -inline void XtcpFlatRecord::clear_type_of_service() { +// uint32 inet_diag_tos = 1401 [json_name = "inetDiagTos"]; +inline void XtcpFlatRecord::clear_inet_diag_tos() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_of_service_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000002U); + _impl_.inet_diag_tos_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00000010U); } -inline ::uint32_t XtcpFlatRecord::type_of_service() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) - return _internal_type_of_service(); +inline ::uint32_t XtcpFlatRecord::inet_diag_tos() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_tos) + return _internal_inet_diag_tos(); } -inline void XtcpFlatRecord::set_type_of_service(::uint32_t value) { - _internal_set_type_of_service(value); - SetHasBit(_impl_._has_bits_[4], 0x00000002U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.type_of_service) +inline void XtcpFlatRecord::set_inet_diag_tos(::uint32_t value) { + _internal_set_inet_diag_tos(value); + SetHasBit(_impl_._has_bits_[4], 0x00000010U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_tos) } -inline ::uint32_t XtcpFlatRecord::_internal_type_of_service() const { +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_tos() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_of_service_; + return _impl_.inet_diag_tos_; } -inline void XtcpFlatRecord::_internal_set_type_of_service(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_tos(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_of_service_ = value; + _impl_.inet_diag_tos_ = value; } -// uint32 traffic_class = 1402 [json_name = "trafficClass"]; -inline void XtcpFlatRecord::clear_traffic_class() { +// uint32 inet_diag_tclass = 1402 [json_name = "inetDiagTclass"]; +inline void XtcpFlatRecord::clear_inet_diag_tclass() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.traffic_class_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000004U); + _impl_.inet_diag_tclass_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00000020U); } -inline ::uint32_t XtcpFlatRecord::traffic_class() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) - return _internal_traffic_class(); +inline ::uint32_t XtcpFlatRecord::inet_diag_tclass() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_tclass) + return _internal_inet_diag_tclass(); } -inline void XtcpFlatRecord::set_traffic_class(::uint32_t value) { - _internal_set_traffic_class(value); - SetHasBit(_impl_._has_bits_[4], 0x00000004U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.traffic_class) +inline void XtcpFlatRecord::set_inet_diag_tclass(::uint32_t value) { + _internal_set_inet_diag_tclass(value); + SetHasBit(_impl_._has_bits_[4], 0x00000020U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_tclass) } -inline ::uint32_t XtcpFlatRecord::_internal_traffic_class() const { +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_tclass() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.traffic_class_; + return _impl_.inet_diag_tclass_; } -inline void XtcpFlatRecord::_internal_set_traffic_class(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_tclass(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.traffic_class_ = value; + _impl_.inet_diag_tclass_ = value; } // uint32 sk_mem_info_rmem_alloc = 1501 [json_name = "skMemInfoRmemAlloc"]; inline void XtcpFlatRecord::clear_sk_mem_info_rmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_rmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000008U); + ClearHasBit(_impl_._has_bits_[4], 0x00000040U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) @@ -8015,7 +8213,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_rmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_rmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_rmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000008U); + SetHasBit(_impl_._has_bits_[4], 0x00000040U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rmem_alloc() const { @@ -8027,35 +8225,35 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_rmem_alloc(::uint32_t valu _impl_.sk_mem_info_rmem_alloc_ = value; } -// uint32 sk_mem_info_rcv_buf = 1502 [json_name = "skMemInfoRcvBuf"]; -inline void XtcpFlatRecord::clear_sk_mem_info_rcv_buf() { +// uint32 sk_mem_info_rcvbuf = 1502 [json_name = "skMemInfoRcvbuf"]; +inline void XtcpFlatRecord::clear_sk_mem_info_rcvbuf() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sk_mem_info_rcv_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000010U); + _impl_.sk_mem_info_rcvbuf_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00000080U); } -inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcv_buf() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) - return _internal_sk_mem_info_rcv_buf(); +inline ::uint32_t XtcpFlatRecord::sk_mem_info_rcvbuf() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcvbuf) + return _internal_sk_mem_info_rcvbuf(); } -inline void XtcpFlatRecord::set_sk_mem_info_rcv_buf(::uint32_t value) { - _internal_set_sk_mem_info_rcv_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000010U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcv_buf) +inline void XtcpFlatRecord::set_sk_mem_info_rcvbuf(::uint32_t value) { + _internal_set_sk_mem_info_rcvbuf(value); + SetHasBit(_impl_._has_bits_[4], 0x00000080U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_rcvbuf) } -inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rcv_buf() const { +inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_rcvbuf() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.sk_mem_info_rcv_buf_; + return _impl_.sk_mem_info_rcvbuf_; } -inline void XtcpFlatRecord::_internal_set_sk_mem_info_rcv_buf(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_sk_mem_info_rcvbuf(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sk_mem_info_rcv_buf_ = value; + _impl_.sk_mem_info_rcvbuf_ = value; } // uint32 sk_mem_info_wmem_alloc = 1503 [json_name = "skMemInfoWmemAlloc"]; inline void XtcpFlatRecord::clear_sk_mem_info_wmem_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000020U); + ClearHasBit(_impl_._has_bits_[4], 0x00000100U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) @@ -8063,7 +8261,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_alloc(::uint32_t value) { _internal_set_sk_mem_info_wmem_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000020U); + SetHasBit(_impl_._has_bits_[4], 0x00000100U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_alloc() const { @@ -8075,35 +8273,35 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_alloc(::uint32_t valu _impl_.sk_mem_info_wmem_alloc_ = value; } -// uint32 sk_mem_info_snd_buf = 1504 [json_name = "skMemInfoSndBuf"]; -inline void XtcpFlatRecord::clear_sk_mem_info_snd_buf() { +// uint32 sk_mem_info_sndbuf = 1504 [json_name = "skMemInfoSndbuf"]; +inline void XtcpFlatRecord::clear_sk_mem_info_sndbuf() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sk_mem_info_snd_buf_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000040U); + _impl_.sk_mem_info_sndbuf_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00000200U); } -inline ::uint32_t XtcpFlatRecord::sk_mem_info_snd_buf() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) - return _internal_sk_mem_info_snd_buf(); +inline ::uint32_t XtcpFlatRecord::sk_mem_info_sndbuf() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_sndbuf) + return _internal_sk_mem_info_sndbuf(); } -inline void XtcpFlatRecord::set_sk_mem_info_snd_buf(::uint32_t value) { - _internal_set_sk_mem_info_snd_buf(value); - SetHasBit(_impl_._has_bits_[4], 0x00000040U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_snd_buf) +inline void XtcpFlatRecord::set_sk_mem_info_sndbuf(::uint32_t value) { + _internal_set_sk_mem_info_sndbuf(value); + SetHasBit(_impl_._has_bits_[4], 0x00000200U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_sndbuf) } -inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_snd_buf() const { +inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_sndbuf() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.sk_mem_info_snd_buf_; + return _impl_.sk_mem_info_sndbuf_; } -inline void XtcpFlatRecord::_internal_set_sk_mem_info_snd_buf(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_sk_mem_info_sndbuf(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sk_mem_info_snd_buf_ = value; + _impl_.sk_mem_info_sndbuf_ = value; } // uint32 sk_mem_info_fwd_alloc = 1505 [json_name = "skMemInfoFwdAlloc"]; inline void XtcpFlatRecord::clear_sk_mem_info_fwd_alloc() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_fwd_alloc_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000080U); + ClearHasBit(_impl_._has_bits_[4], 0x00000400U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) @@ -8111,7 +8309,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_fwd_alloc() const { } inline void XtcpFlatRecord::set_sk_mem_info_fwd_alloc(::uint32_t value) { _internal_set_sk_mem_info_fwd_alloc(value); - SetHasBit(_impl_._has_bits_[4], 0x00000080U); + SetHasBit(_impl_._has_bits_[4], 0x00000400U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_fwd_alloc) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_fwd_alloc() const { @@ -8127,7 +8325,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_fwd_alloc(::uint32_t value inline void XtcpFlatRecord::clear_sk_mem_info_wmem_queued() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_wmem_queued_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000100U); + ClearHasBit(_impl_._has_bits_[4], 0x00000800U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) @@ -8135,7 +8333,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_wmem_queued() const { } inline void XtcpFlatRecord::set_sk_mem_info_wmem_queued(::uint32_t value) { _internal_set_sk_mem_info_wmem_queued(value); - SetHasBit(_impl_._has_bits_[4], 0x00000100U); + SetHasBit(_impl_._has_bits_[4], 0x00000800U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_wmem_queued) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_wmem_queued() const { @@ -8151,7 +8349,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_wmem_queued(::uint32_t val inline void XtcpFlatRecord::clear_sk_mem_info_optmem() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_optmem_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000200U); + ClearHasBit(_impl_._has_bits_[4], 0x00001000U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) @@ -8159,7 +8357,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_optmem() const { } inline void XtcpFlatRecord::set_sk_mem_info_optmem(::uint32_t value) { _internal_set_sk_mem_info_optmem(value); - SetHasBit(_impl_._has_bits_[4], 0x00000200U); + SetHasBit(_impl_._has_bits_[4], 0x00001000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_optmem) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_optmem() const { @@ -8175,7 +8373,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_optmem(::uint32_t value) { inline void XtcpFlatRecord::clear_sk_mem_info_backlog() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_backlog_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000400U); + ClearHasBit(_impl_._has_bits_[4], 0x00002000U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) @@ -8183,7 +8381,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_backlog() const { } inline void XtcpFlatRecord::set_sk_mem_info_backlog(::uint32_t value) { _internal_set_sk_mem_info_backlog(value); - SetHasBit(_impl_._has_bits_[4], 0x00000400U); + SetHasBit(_impl_._has_bits_[4], 0x00002000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_backlog) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_backlog() const { @@ -8199,7 +8397,7 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_backlog(::uint32_t value) inline void XtcpFlatRecord::clear_sk_mem_info_drops() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.sk_mem_info_drops_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00000800U); + ClearHasBit(_impl_._has_bits_[4], 0x00004000U); } inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) @@ -8207,7 +8405,7 @@ inline ::uint32_t XtcpFlatRecord::sk_mem_info_drops() const { } inline void XtcpFlatRecord::set_sk_mem_info_drops(::uint32_t value) { _internal_set_sk_mem_info_drops(value); - SetHasBit(_impl_._has_bits_[4], 0x00000800U); + SetHasBit(_impl_._has_bits_[4], 0x00004000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sk_mem_info_drops) } inline ::uint32_t XtcpFlatRecord::_internal_sk_mem_info_drops() const { @@ -8219,35 +8417,35 @@ inline void XtcpFlatRecord::_internal_set_sk_mem_info_drops(::uint32_t value) { _impl_.sk_mem_info_drops_ = value; } -// uint32 shutdown_state = 1600 [json_name = "shutdownState"]; -inline void XtcpFlatRecord::clear_shutdown_state() { +// uint32 inet_diag_shutdown = 1600 [json_name = "inetDiagShutdown"]; +inline void XtcpFlatRecord::clear_inet_diag_shutdown() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.shutdown_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00001000U); + _impl_.inet_diag_shutdown_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00008000U); } -inline ::uint32_t XtcpFlatRecord::shutdown_state() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) - return _internal_shutdown_state(); +inline ::uint32_t XtcpFlatRecord::inet_diag_shutdown() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_shutdown) + return _internal_inet_diag_shutdown(); } -inline void XtcpFlatRecord::set_shutdown_state(::uint32_t value) { - _internal_set_shutdown_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00001000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.shutdown_state) +inline void XtcpFlatRecord::set_inet_diag_shutdown(::uint32_t value) { + _internal_set_inet_diag_shutdown(value); + SetHasBit(_impl_._has_bits_[4], 0x00008000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_shutdown) } -inline ::uint32_t XtcpFlatRecord::_internal_shutdown_state() const { +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_shutdown() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.shutdown_state_; + return _impl_.inet_diag_shutdown_; } -inline void XtcpFlatRecord::_internal_set_shutdown_state(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_shutdown(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.shutdown_state_ = value; + _impl_.inet_diag_shutdown_ = value; } // uint32 vegas_info_enabled = 1701 [json_name = "vegasInfoEnabled"]; inline void XtcpFlatRecord::clear_vegas_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00002000U); + ClearHasBit(_impl_._has_bits_[4], 0x00010000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) @@ -8255,7 +8453,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_enabled() const { } inline void XtcpFlatRecord::set_vegas_info_enabled(::uint32_t value) { _internal_set_vegas_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00002000U); + SetHasBit(_impl_._has_bits_[4], 0x00010000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_enabled() const { @@ -8267,35 +8465,35 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_enabled(::uint32_t value) { _impl_.vegas_info_enabled_ = value; } -// uint32 vegas_info_rtt_cnt = 1702 [json_name = "vegasInfoRttCnt"]; -inline void XtcpFlatRecord::clear_vegas_info_rtt_cnt() { +// uint32 vegas_info_rttcnt = 1702 [json_name = "vegasInfoRttcnt"]; +inline void XtcpFlatRecord::clear_vegas_info_rttcnt() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.vegas_info_rtt_cnt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00004000U); + _impl_.vegas_info_rttcnt_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00020000U); } -inline ::uint32_t XtcpFlatRecord::vegas_info_rtt_cnt() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) - return _internal_vegas_info_rtt_cnt(); +inline ::uint32_t XtcpFlatRecord::vegas_info_rttcnt() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rttcnt) + return _internal_vegas_info_rttcnt(); } -inline void XtcpFlatRecord::set_vegas_info_rtt_cnt(::uint32_t value) { - _internal_set_vegas_info_rtt_cnt(value); - SetHasBit(_impl_._has_bits_[4], 0x00004000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt_cnt) +inline void XtcpFlatRecord::set_vegas_info_rttcnt(::uint32_t value) { + _internal_set_vegas_info_rttcnt(value); + SetHasBit(_impl_._has_bits_[4], 0x00020000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rttcnt) } -inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt_cnt() const { +inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rttcnt() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.vegas_info_rtt_cnt_; + return _impl_.vegas_info_rttcnt_; } -inline void XtcpFlatRecord::_internal_set_vegas_info_rtt_cnt(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_vegas_info_rttcnt(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.vegas_info_rtt_cnt_ = value; + _impl_.vegas_info_rttcnt_ = value; } // uint32 vegas_info_rtt = 1703 [json_name = "vegasInfoRtt"]; inline void XtcpFlatRecord::clear_vegas_info_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.vegas_info_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00008000U); + ClearHasBit(_impl_._has_bits_[4], 0x00040000U); } inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) @@ -8303,7 +8501,7 @@ inline ::uint32_t XtcpFlatRecord::vegas_info_rtt() const { } inline void XtcpFlatRecord::set_vegas_info_rtt(::uint32_t value) { _internal_set_vegas_info_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00008000U); + SetHasBit(_impl_._has_bits_[4], 0x00040000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_rtt() const { @@ -8315,35 +8513,35 @@ inline void XtcpFlatRecord::_internal_set_vegas_info_rtt(::uint32_t value) { _impl_.vegas_info_rtt_ = value; } -// uint32 vegas_info_min_rtt = 1704 [json_name = "vegasInfoMinRtt"]; -inline void XtcpFlatRecord::clear_vegas_info_min_rtt() { +// uint32 vegas_info_minrtt = 1704 [json_name = "vegasInfoMinrtt"]; +inline void XtcpFlatRecord::clear_vegas_info_minrtt() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.vegas_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00010000U); + _impl_.vegas_info_minrtt_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x00080000U); } -inline ::uint32_t XtcpFlatRecord::vegas_info_min_rtt() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) - return _internal_vegas_info_min_rtt(); +inline ::uint32_t XtcpFlatRecord::vegas_info_minrtt() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_minrtt) + return _internal_vegas_info_minrtt(); } -inline void XtcpFlatRecord::set_vegas_info_min_rtt(::uint32_t value) { - _internal_set_vegas_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x00010000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_min_rtt) +inline void XtcpFlatRecord::set_vegas_info_minrtt(::uint32_t value) { + _internal_set_vegas_info_minrtt(value); + SetHasBit(_impl_._has_bits_[4], 0x00080000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.vegas_info_minrtt) } -inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_min_rtt() const { +inline ::uint32_t XtcpFlatRecord::_internal_vegas_info_minrtt() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.vegas_info_min_rtt_; + return _impl_.vegas_info_minrtt_; } -inline void XtcpFlatRecord::_internal_set_vegas_info_min_rtt(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_vegas_info_minrtt(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.vegas_info_min_rtt_ = value; + _impl_.vegas_info_minrtt_ = value; } // uint32 dctcp_info_enabled = 1801 [json_name = "dctcpInfoEnabled"]; inline void XtcpFlatRecord::clear_dctcp_info_enabled() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_enabled_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00020000U); + ClearHasBit(_impl_._has_bits_[4], 0x00100000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) @@ -8351,7 +8549,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_enabled() const { } inline void XtcpFlatRecord::set_dctcp_info_enabled(::uint32_t value) { _internal_set_dctcp_info_enabled(value); - SetHasBit(_impl_._has_bits_[4], 0x00020000U); + SetHasBit(_impl_._has_bits_[4], 0x00100000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_enabled) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_enabled() const { @@ -8367,7 +8565,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_enabled(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ce_state() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ce_state_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00040000U); + ClearHasBit(_impl_._has_bits_[4], 0x00200000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) @@ -8375,7 +8573,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ce_state() const { } inline void XtcpFlatRecord::set_dctcp_info_ce_state(::uint32_t value) { _internal_set_dctcp_info_ce_state(value); - SetHasBit(_impl_._has_bits_[4], 0x00040000U); + SetHasBit(_impl_._has_bits_[4], 0x00200000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ce_state) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ce_state() const { @@ -8391,7 +8589,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ce_state(::uint32_t value) inline void XtcpFlatRecord::clear_dctcp_info_alpha() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_alpha_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00080000U); + ClearHasBit(_impl_._has_bits_[4], 0x00400000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) @@ -8399,7 +8597,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_alpha() const { } inline void XtcpFlatRecord::set_dctcp_info_alpha(::uint32_t value) { _internal_set_dctcp_info_alpha(value); - SetHasBit(_impl_._has_bits_[4], 0x00080000U); + SetHasBit(_impl_._has_bits_[4], 0x00400000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_alpha) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_alpha() const { @@ -8415,7 +8613,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_alpha(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_ecn() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_ecn_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00100000U); + ClearHasBit(_impl_._has_bits_[4], 0x00800000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) @@ -8423,7 +8621,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_ecn() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_ecn(::uint32_t value) { _internal_set_dctcp_info_ab_ecn(value); - SetHasBit(_impl_._has_bits_[4], 0x00100000U); + SetHasBit(_impl_._has_bits_[4], 0x00800000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_ecn) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_ecn() const { @@ -8439,7 +8637,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_ecn(::uint32_t value) { inline void XtcpFlatRecord::clear_dctcp_info_ab_tot() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.dctcp_info_ab_tot_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00200000U); + ClearHasBit(_impl_._has_bits_[4], 0x01000000U); } inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) @@ -8447,7 +8645,7 @@ inline ::uint32_t XtcpFlatRecord::dctcp_info_ab_tot() const { } inline void XtcpFlatRecord::set_dctcp_info_ab_tot(::uint32_t value) { _internal_set_dctcp_info_ab_tot(value); - SetHasBit(_impl_._has_bits_[4], 0x00200000U); + SetHasBit(_impl_._has_bits_[4], 0x01000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.dctcp_info_ab_tot) } inline ::uint32_t XtcpFlatRecord::_internal_dctcp_info_ab_tot() const { @@ -8463,7 +8661,7 @@ inline void XtcpFlatRecord::_internal_set_dctcp_info_ab_tot(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_lo() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_lo_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00400000U); + ClearHasBit(_impl_._has_bits_[4], 0x02000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) @@ -8471,7 +8669,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_lo() const { } inline void XtcpFlatRecord::set_bbr_info_bw_lo(::uint32_t value) { _internal_set_bbr_info_bw_lo(value); - SetHasBit(_impl_._has_bits_[4], 0x00400000U); + SetHasBit(_impl_._has_bits_[4], 0x02000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_lo) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_lo() const { @@ -8487,7 +8685,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_lo(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_bw_hi() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_bw_hi_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x00800000U); + ClearHasBit(_impl_._has_bits_[4], 0x04000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) @@ -8495,7 +8693,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_bw_hi() const { } inline void XtcpFlatRecord::set_bbr_info_bw_hi(::uint32_t value) { _internal_set_bbr_info_bw_hi(value); - SetHasBit(_impl_._has_bits_[4], 0x00800000U); + SetHasBit(_impl_._has_bits_[4], 0x04000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_bw_hi) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_bw_hi() const { @@ -8511,7 +8709,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_bw_hi(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_min_rtt() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_min_rtt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x01000000U); + ClearHasBit(_impl_._has_bits_[4], 0x08000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) @@ -8519,7 +8717,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_min_rtt() const { } inline void XtcpFlatRecord::set_bbr_info_min_rtt(::uint32_t value) { _internal_set_bbr_info_min_rtt(value); - SetHasBit(_impl_._has_bits_[4], 0x01000000U); + SetHasBit(_impl_._has_bits_[4], 0x08000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_min_rtt) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_min_rtt() const { @@ -8535,7 +8733,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_min_rtt(::uint32_t value) { inline void XtcpFlatRecord::clear_bbr_info_pacing_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_pacing_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x02000000U); + ClearHasBit(_impl_._has_bits_[4], 0x10000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) @@ -8543,7 +8741,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_pacing_gain() const { } inline void XtcpFlatRecord::set_bbr_info_pacing_gain(::uint32_t value) { _internal_set_bbr_info_pacing_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x02000000U); + SetHasBit(_impl_._has_bits_[4], 0x10000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_pacing_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_pacing_gain() const { @@ -8559,7 +8757,7 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_pacing_gain(::uint32_t value) inline void XtcpFlatRecord::clear_bbr_info_cwnd_gain() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.bbr_info_cwnd_gain_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x04000000U); + ClearHasBit(_impl_._has_bits_[4], 0x20000000U); } inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) @@ -8567,7 +8765,7 @@ inline ::uint32_t XtcpFlatRecord::bbr_info_cwnd_gain() const { } inline void XtcpFlatRecord::set_bbr_info_cwnd_gain(::uint32_t value) { _internal_set_bbr_info_cwnd_gain(value); - SetHasBit(_impl_._has_bits_[4], 0x04000000U); + SetHasBit(_impl_._has_bits_[4], 0x20000000U); // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.bbr_info_cwnd_gain) } inline ::uint32_t XtcpFlatRecord::_internal_bbr_info_cwnd_gain() const { @@ -8579,76 +8777,76 @@ inline void XtcpFlatRecord::_internal_set_bbr_info_cwnd_gain(::uint32_t value) { _impl_.bbr_info_cwnd_gain_ = value; } -// uint32 class_id = 2001 [json_name = "classId"]; -inline void XtcpFlatRecord::clear_class_id() { +// uint32 inet_diag_class_id = 2001 [json_name = "inetDiagClassId"]; +inline void XtcpFlatRecord::clear_inet_diag_class_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.class_id_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x08000000U); + _impl_.inet_diag_class_id_ = 0u; + ClearHasBit(_impl_._has_bits_[4], 0x40000000U); } -inline ::uint32_t XtcpFlatRecord::class_id() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.class_id) - return _internal_class_id(); +inline ::uint32_t XtcpFlatRecord::inet_diag_class_id() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_class_id) + return _internal_inet_diag_class_id(); } -inline void XtcpFlatRecord::set_class_id(::uint32_t value) { - _internal_set_class_id(value); - SetHasBit(_impl_._has_bits_[4], 0x08000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.class_id) +inline void XtcpFlatRecord::set_inet_diag_class_id(::uint32_t value) { + _internal_set_inet_diag_class_id(value); + SetHasBit(_impl_._has_bits_[4], 0x40000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_class_id) } -inline ::uint32_t XtcpFlatRecord::_internal_class_id() const { +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_class_id() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.class_id_; + return _impl_.inet_diag_class_id_; } -inline void XtcpFlatRecord::_internal_set_class_id(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_class_id(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.class_id_ = value; + _impl_.inet_diag_class_id_ = value; } -// uint32 sock_opt = 2002 [json_name = "sockOpt"]; -inline void XtcpFlatRecord::clear_sock_opt() { +// uint32 inet_diag_sockopt = 2002 [json_name = "inetDiagSockopt"]; +inline void XtcpFlatRecord::clear_inet_diag_sockopt() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sock_opt_ = 0u; - ClearHasBit(_impl_._has_bits_[4], 0x20000000U); + _impl_.inet_diag_sockopt_ = 0u; + ClearHasBit(_impl_._has_bits_[5], 0x00000001U); } -inline ::uint32_t XtcpFlatRecord::sock_opt() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) - return _internal_sock_opt(); +inline ::uint32_t XtcpFlatRecord::inet_diag_sockopt() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_sockopt) + return _internal_inet_diag_sockopt(); } -inline void XtcpFlatRecord::set_sock_opt(::uint32_t value) { - _internal_set_sock_opt(value); - SetHasBit(_impl_._has_bits_[4], 0x20000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.sock_opt) +inline void XtcpFlatRecord::set_inet_diag_sockopt(::uint32_t value) { + _internal_set_inet_diag_sockopt(value); + SetHasBit(_impl_._has_bits_[5], 0x00000001U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_sockopt) } -inline ::uint32_t XtcpFlatRecord::_internal_sock_opt() const { +inline ::uint32_t XtcpFlatRecord::_internal_inet_diag_sockopt() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.sock_opt_; + return _impl_.inet_diag_sockopt_; } -inline void XtcpFlatRecord::_internal_set_sock_opt(::uint32_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_sockopt(::uint32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sock_opt_ = value; + _impl_.inet_diag_sockopt_ = value; } -// uint64 c_group = 2103 [json_name = "cGroup"]; -inline void XtcpFlatRecord::clear_c_group() { +// uint64 inet_diag_cgroup_id = 2003 [json_name = "inetDiagCgroupId"]; +inline void XtcpFlatRecord::clear_inet_diag_cgroup_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.c_group_ = ::uint64_t{0u}; - ClearHasBit(_impl_._has_bits_[4], 0x10000000U); + _impl_.inet_diag_cgroup_id_ = ::uint64_t{0u}; + ClearHasBit(_impl_._has_bits_[4], 0x80000000U); } -inline ::uint64_t XtcpFlatRecord::c_group() const { - // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.c_group) - return _internal_c_group(); +inline ::uint64_t XtcpFlatRecord::inet_diag_cgroup_id() const { + // @@protoc_insertion_point(field_get:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cgroup_id) + return _internal_inet_diag_cgroup_id(); } -inline void XtcpFlatRecord::set_c_group(::uint64_t value) { - _internal_set_c_group(value); - SetHasBit(_impl_._has_bits_[4], 0x10000000U); - // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.c_group) +inline void XtcpFlatRecord::set_inet_diag_cgroup_id(::uint64_t value) { + _internal_set_inet_diag_cgroup_id(value); + SetHasBit(_impl_._has_bits_[4], 0x80000000U); + // @@protoc_insertion_point(field_set:xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cgroup_id) } -inline ::uint64_t XtcpFlatRecord::_internal_c_group() const { +inline ::uint64_t XtcpFlatRecord::_internal_inet_diag_cgroup_id() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.c_group_; + return _impl_.inet_diag_cgroup_id_; } -inline void XtcpFlatRecord::_internal_set_c_group(::uint64_t value) { +inline void XtcpFlatRecord::_internal_set_inet_diag_cgroup_id(::uint64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.c_group_ = value; + _impl_.inet_diag_cgroup_id_ = value; } // ------------------------------------------------------------------- diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart index f2468dd..809d664 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pb.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pb.dart @@ -856,65 +856,84 @@ class SetEnvelopeFlushResponse extends $pb.GeneratedMessage { } /// xtcp configuration +/// +/// Field-number layout (renumbered into subject blocks 2026-09; the binary form +/// is never persisted — it only crosses the gRPC hop between xtcp2 and +/// xtcp2ctl/xtcp2client, which are built from this repo's gen/go together, and +/// protojson/prototext map by NAME — so renumbering is safe). Add new knobs in +/// the free space of the matching block; open a new block above 250 for a new +/// subject. +/// 10-39 polling & netlink (dump cadence, netlinker plumbing, io_uring) +/// 40-49 namespace reconcile +/// 50-59 capture / debug +/// 60-79 output, destination-agnostic (dest, marshal, csv, envelope) +/// 80-99 kafka destination +/// 100-129 s3parquet destination +/// 130-149 identity & labels stamped on every record +/// 150-159 network knobs for xtcp2's own listeners +/// 160-169 gRPC +/// 170-179 profiling +/// 200-249 best-effort enrichment (container 200s, lldp 210s, nic 220s, +/// nsid 230s, asn 240-244, locality 245-249) class XtcpConfig extends $pb.GeneratedMessage { factory XtcpConfig({ $fixnum.Int64? nlTimeoutMilliseconds, $1.Duration? pollFrequency, $1.Duration? pollTimeout, + $core.int? pollJitterPct, $fixnum.Int64? maxLoops, $core.int? netlinkers, $core.int? netlinkersDoneChanSize, $core.int? nlmsgSeq, $fixnum.Int64? packetSize, $core.int? packetSizeMply, + $fixnum.Int64? modulus, + EnabledDeserializers? enabledDeserializers, + $core.bool? ioUring, + $core.int? ioUringRecvBatchSize, + $core.int? ioUringCqeBatchSize, + $1.Duration? reconcileFrequency, + $core.bool? reconcileBeforePoll, $core.int? writeFiles, $core.String? capturePath, - $fixnum.Int64? modulus, + $core.int? destWriteFiles, + $core.int? debugLevel, + $core.String? dest, $core.String? marshalTo, + $core.String? csvColumns, + $core.String? xtcpProtoFile, $core.int? envelopeFlushThresholdBytes, $core.int? envelopeFlushThresholdRows, + $core.String? topic, + $core.String? kafkaSchemaUrl, + $1.Duration? kafkaProduceTimeout, $core.String? kafkaCompression, $core.String? s3Endpoint, + $core.String? s3Region, $core.String? s3Bucket, $core.String? s3Prefix, $core.String? s3AccessKey, $core.String? s3SecretKey, - $core.String? dest, - $core.int? s3ParquetFlushThresholdBytes, - $core.String? s3Region, $core.bool? s3SkipBucketProbe, - $core.int? destWriteFiles, - $core.String? pyroscopeUrl, - $core.String? pyroscopeAppName, - $core.int? pyroscopeSampleHz, - $core.int? pyroscopeUploadIntervalSec, - $core.String? topic, - $core.String? xtcpProtoFile, - $core.String? kafkaSchemaUrl, - $1.Duration? kafkaProduceTimeout, - $core.int? debugLevel, - $core.String? label, - $core.String? tag, - $core.String? location, - $core.String? hostname, - $core.bool? resolveContainerId, - $core.int? ipv4Ttl, - $core.int? ipv6HopLimit, - $core.String? daemonVersion, - $core.int? grpcPort, - EnabledDeserializers? enabledDeserializers, - $core.bool? ioUring, - $core.int? ioUringRecvBatchSize, - $core.int? ioUringCqeBatchSize, - $core.String? csvColumns, - $core.int? pollJitterPct, + $core.int? s3ParquetFlushThresholdBytes, $1.Duration? s3FlushInterval, $core.int? s3FlushJitterPct, $core.int? s3FlushThresholdJitterPct, $core.int? s3UploadMaxAttempts, $1.Duration? s3UploadBackoffCap, - $1.Duration? reconcileFrequency, - $core.bool? reconcileBeforePoll, + $core.String? hostname, + $core.String? location, + $core.String? label, + $core.String? tag, + $core.String? daemonVersion, + $core.int? ipv4Ttl, + $core.int? ipv6HopLimit, + $core.int? grpcPort, + $core.String? pyroscopeUrl, + $core.String? pyroscopeAppName, + $core.int? pyroscopeSampleHz, + $core.int? pyroscopeUploadIntervalSec, + $core.bool? resolveContainerId, $core.bool? enrichContainerEnable, $core.String? dockerSocketPath, $core.bool? enrichLldpEnable, @@ -935,6 +954,7 @@ class XtcpConfig extends $pb.GeneratedMessage { result.nlTimeoutMilliseconds = nlTimeoutMilliseconds; if (pollFrequency != null) result.pollFrequency = pollFrequency; if (pollTimeout != null) result.pollTimeout = pollTimeout; + if (pollJitterPct != null) result.pollJitterPct = pollJitterPct; if (maxLoops != null) result.maxLoops = maxLoops; if (netlinkers != null) result.netlinkers = netlinkers; if (netlinkersDoneChanSize != null) @@ -942,56 +962,44 @@ class XtcpConfig extends $pb.GeneratedMessage { if (nlmsgSeq != null) result.nlmsgSeq = nlmsgSeq; if (packetSize != null) result.packetSize = packetSize; if (packetSizeMply != null) result.packetSizeMply = packetSizeMply; + if (modulus != null) result.modulus = modulus; + if (enabledDeserializers != null) + result.enabledDeserializers = enabledDeserializers; + if (ioUring != null) result.ioUring = ioUring; + if (ioUringRecvBatchSize != null) + result.ioUringRecvBatchSize = ioUringRecvBatchSize; + if (ioUringCqeBatchSize != null) + result.ioUringCqeBatchSize = ioUringCqeBatchSize; + if (reconcileFrequency != null) + result.reconcileFrequency = reconcileFrequency; + if (reconcileBeforePoll != null) + result.reconcileBeforePoll = reconcileBeforePoll; if (writeFiles != null) result.writeFiles = writeFiles; if (capturePath != null) result.capturePath = capturePath; - if (modulus != null) result.modulus = modulus; + if (destWriteFiles != null) result.destWriteFiles = destWriteFiles; + if (debugLevel != null) result.debugLevel = debugLevel; + if (dest != null) result.dest = dest; if (marshalTo != null) result.marshalTo = marshalTo; + if (csvColumns != null) result.csvColumns = csvColumns; + if (xtcpProtoFile != null) result.xtcpProtoFile = xtcpProtoFile; if (envelopeFlushThresholdBytes != null) result.envelopeFlushThresholdBytes = envelopeFlushThresholdBytes; if (envelopeFlushThresholdRows != null) result.envelopeFlushThresholdRows = envelopeFlushThresholdRows; + if (topic != null) result.topic = topic; + if (kafkaSchemaUrl != null) result.kafkaSchemaUrl = kafkaSchemaUrl; + if (kafkaProduceTimeout != null) + result.kafkaProduceTimeout = kafkaProduceTimeout; if (kafkaCompression != null) result.kafkaCompression = kafkaCompression; if (s3Endpoint != null) result.s3Endpoint = s3Endpoint; + if (s3Region != null) result.s3Region = s3Region; if (s3Bucket != null) result.s3Bucket = s3Bucket; if (s3Prefix != null) result.s3Prefix = s3Prefix; if (s3AccessKey != null) result.s3AccessKey = s3AccessKey; if (s3SecretKey != null) result.s3SecretKey = s3SecretKey; - if (dest != null) result.dest = dest; + if (s3SkipBucketProbe != null) result.s3SkipBucketProbe = s3SkipBucketProbe; if (s3ParquetFlushThresholdBytes != null) result.s3ParquetFlushThresholdBytes = s3ParquetFlushThresholdBytes; - if (s3Region != null) result.s3Region = s3Region; - if (s3SkipBucketProbe != null) result.s3SkipBucketProbe = s3SkipBucketProbe; - if (destWriteFiles != null) result.destWriteFiles = destWriteFiles; - if (pyroscopeUrl != null) result.pyroscopeUrl = pyroscopeUrl; - if (pyroscopeAppName != null) result.pyroscopeAppName = pyroscopeAppName; - if (pyroscopeSampleHz != null) result.pyroscopeSampleHz = pyroscopeSampleHz; - if (pyroscopeUploadIntervalSec != null) - result.pyroscopeUploadIntervalSec = pyroscopeUploadIntervalSec; - if (topic != null) result.topic = topic; - if (xtcpProtoFile != null) result.xtcpProtoFile = xtcpProtoFile; - if (kafkaSchemaUrl != null) result.kafkaSchemaUrl = kafkaSchemaUrl; - if (kafkaProduceTimeout != null) - result.kafkaProduceTimeout = kafkaProduceTimeout; - if (debugLevel != null) result.debugLevel = debugLevel; - if (label != null) result.label = label; - if (tag != null) result.tag = tag; - if (location != null) result.location = location; - if (hostname != null) result.hostname = hostname; - if (resolveContainerId != null) - result.resolveContainerId = resolveContainerId; - if (ipv4Ttl != null) result.ipv4Ttl = ipv4Ttl; - if (ipv6HopLimit != null) result.ipv6HopLimit = ipv6HopLimit; - if (daemonVersion != null) result.daemonVersion = daemonVersion; - if (grpcPort != null) result.grpcPort = grpcPort; - if (enabledDeserializers != null) - result.enabledDeserializers = enabledDeserializers; - if (ioUring != null) result.ioUring = ioUring; - if (ioUringRecvBatchSize != null) - result.ioUringRecvBatchSize = ioUringRecvBatchSize; - if (ioUringCqeBatchSize != null) - result.ioUringCqeBatchSize = ioUringCqeBatchSize; - if (csvColumns != null) result.csvColumns = csvColumns; - if (pollJitterPct != null) result.pollJitterPct = pollJitterPct; if (s3FlushInterval != null) result.s3FlushInterval = s3FlushInterval; if (s3FlushJitterPct != null) result.s3FlushJitterPct = s3FlushJitterPct; if (s3FlushThresholdJitterPct != null) @@ -1000,10 +1008,21 @@ class XtcpConfig extends $pb.GeneratedMessage { result.s3UploadMaxAttempts = s3UploadMaxAttempts; if (s3UploadBackoffCap != null) result.s3UploadBackoffCap = s3UploadBackoffCap; - if (reconcileFrequency != null) - result.reconcileFrequency = reconcileFrequency; - if (reconcileBeforePoll != null) - result.reconcileBeforePoll = reconcileBeforePoll; + if (hostname != null) result.hostname = hostname; + if (location != null) result.location = location; + if (label != null) result.label = label; + if (tag != null) result.tag = tag; + if (daemonVersion != null) result.daemonVersion = daemonVersion; + if (ipv4Ttl != null) result.ipv4Ttl = ipv4Ttl; + if (ipv6HopLimit != null) result.ipv6HopLimit = ipv6HopLimit; + if (grpcPort != null) result.grpcPort = grpcPort; + if (pyroscopeUrl != null) result.pyroscopeUrl = pyroscopeUrl; + if (pyroscopeAppName != null) result.pyroscopeAppName = pyroscopeAppName; + if (pyroscopeSampleHz != null) result.pyroscopeSampleHz = pyroscopeSampleHz; + if (pyroscopeUploadIntervalSec != null) + result.pyroscopeUploadIntervalSec = pyroscopeUploadIntervalSec; + if (resolveContainerId != null) + result.resolveContainerId = resolveContainerId; if (enrichContainerEnable != null) result.enrichContainerEnable = enrichContainerEnable; if (dockerSocketPath != null) result.dockerSocketPath = dockerSocketPath; @@ -1042,110 +1061,110 @@ class XtcpConfig extends $pb.GeneratedMessage { ..a<$fixnum.Int64>( 10, _omitFieldNames ? '' : 'nlTimeoutMilliseconds', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) - ..aOM<$1.Duration>(20, _omitFieldNames ? '' : 'pollFrequency', + ..aOM<$1.Duration>(11, _omitFieldNames ? '' : 'pollFrequency', subBuilder: $1.Duration.create) - ..aOM<$1.Duration>(30, _omitFieldNames ? '' : 'pollTimeout', + ..aOM<$1.Duration>(12, _omitFieldNames ? '' : 'pollTimeout', subBuilder: $1.Duration.create) + ..aI(13, _omitFieldNames ? '' : 'pollJitterPct', + fieldType: $pb.PbFieldType.OU3) ..a<$fixnum.Int64>( - 40, _omitFieldNames ? '' : 'maxLoops', $pb.PbFieldType.OU6, + 14, _omitFieldNames ? '' : 'maxLoops', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) - ..aI(50, _omitFieldNames ? '' : 'netlinkers', + ..aI(15, _omitFieldNames ? '' : 'netlinkers', fieldType: $pb.PbFieldType.OU3) - ..aI(51, _omitFieldNames ? '' : 'netlinkersDoneChanSize', + ..aI(16, _omitFieldNames ? '' : 'netlinkersDoneChanSize', fieldType: $pb.PbFieldType.OU3) - ..aI(60, _omitFieldNames ? '' : 'nlmsgSeq', fieldType: $pb.PbFieldType.OU3) + ..aI(17, _omitFieldNames ? '' : 'nlmsgSeq', fieldType: $pb.PbFieldType.OU3) ..a<$fixnum.Int64>( - 70, _omitFieldNames ? '' : 'packetSize', $pb.PbFieldType.OU6, + 18, _omitFieldNames ? '' : 'packetSize', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) - ..aI(80, _omitFieldNames ? '' : 'packetSizeMply', - fieldType: $pb.PbFieldType.OU3) - ..aI(90, _omitFieldNames ? '' : 'writeFiles', + ..aI(19, _omitFieldNames ? '' : 'packetSizeMply', fieldType: $pb.PbFieldType.OU3) - ..aOS(100, _omitFieldNames ? '' : 'capturePath') ..a<$fixnum.Int64>( - 110, _omitFieldNames ? '' : 'modulus', $pb.PbFieldType.OU6, + 20, _omitFieldNames ? '' : 'modulus', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) - ..aOS(120, _omitFieldNames ? '' : 'marshalTo') - ..aI(122, _omitFieldNames ? '' : 'envelopeFlushThresholdBytes', + ..aOM( + 21, _omitFieldNames ? '' : 'enabledDeserializers', + subBuilder: EnabledDeserializers.create) + ..aOB(22, _omitFieldNames ? '' : 'ioUring') + ..aI(23, _omitFieldNames ? '' : 'ioUringRecvBatchSize', fieldType: $pb.PbFieldType.OU3) - ..aI(123, _omitFieldNames ? '' : 'envelopeFlushThresholdRows', + ..aI(24, _omitFieldNames ? '' : 'ioUringCqeBatchSize', fieldType: $pb.PbFieldType.OU3) - ..aOS(124, _omitFieldNames ? '' : 'kafkaCompression') - ..aOS(125, _omitFieldNames ? '' : 's3Endpoint') - ..aOS(126, _omitFieldNames ? '' : 's3Bucket') - ..aOS(127, _omitFieldNames ? '' : 's3Prefix') - ..aOS(128, _omitFieldNames ? '' : 's3AccessKey') - ..aOS(129, _omitFieldNames ? '' : 's3SecretKey') - ..aOS(130, _omitFieldNames ? '' : 'dest') - ..aI(132, _omitFieldNames ? '' : 's3ParquetFlushThresholdBytes', + ..aOM<$1.Duration>(40, _omitFieldNames ? '' : 'reconcileFrequency', + subBuilder: $1.Duration.create) + ..aOB(41, _omitFieldNames ? '' : 'reconcileBeforePoll') + ..aI(50, _omitFieldNames ? '' : 'writeFiles', fieldType: $pb.PbFieldType.OU3) - ..aOS(133, _omitFieldNames ? '' : 's3Region') - ..aOB(134, _omitFieldNames ? '' : 's3SkipBucketProbe') - ..aI(135, _omitFieldNames ? '' : 'destWriteFiles', + ..aOS(51, _omitFieldNames ? '' : 'capturePath') + ..aI(52, _omitFieldNames ? '' : 'destWriteFiles', fieldType: $pb.PbFieldType.OU3) - ..aOS(136, _omitFieldNames ? '' : 'pyroscopeUrl') - ..aOS(137, _omitFieldNames ? '' : 'pyroscopeAppName') - ..aI(138, _omitFieldNames ? '' : 'pyroscopeSampleHz', + ..aI(53, _omitFieldNames ? '' : 'debugLevel', fieldType: $pb.PbFieldType.OU3) - ..aI(139, _omitFieldNames ? '' : 'pyroscopeUploadIntervalSec', + ..aOS(60, _omitFieldNames ? '' : 'dest') + ..aOS(61, _omitFieldNames ? '' : 'marshalTo') + ..aOS(62, _omitFieldNames ? '' : 'csvColumns') + ..aOS(63, _omitFieldNames ? '' : 'xtcpProtoFile') + ..aI(64, _omitFieldNames ? '' : 'envelopeFlushThresholdBytes', fieldType: $pb.PbFieldType.OU3) - ..aOS(140, _omitFieldNames ? '' : 'topic') - ..aOS(143, _omitFieldNames ? '' : 'xtcpProtoFile') - ..aOS(145, _omitFieldNames ? '' : 'kafkaSchemaUrl') - ..aOM<$1.Duration>(150, _omitFieldNames ? '' : 'kafkaProduceTimeout', - subBuilder: $1.Duration.create) - ..aI(160, _omitFieldNames ? '' : 'debugLevel', + ..aI(65, _omitFieldNames ? '' : 'envelopeFlushThresholdRows', fieldType: $pb.PbFieldType.OU3) - ..aOS(170, _omitFieldNames ? '' : 'label') - ..aOS(180, _omitFieldNames ? '' : 'tag') - ..aOS(181, _omitFieldNames ? '' : 'location') - ..aOS(182, _omitFieldNames ? '' : 'hostname') - ..aOB(183, _omitFieldNames ? '' : 'resolveContainerId') - ..aI(184, _omitFieldNames ? '' : 'ipv4Ttl', fieldType: $pb.PbFieldType.OU3) - ..aI(185, _omitFieldNames ? '' : 'ipv6HopLimit', + ..aOS(80, _omitFieldNames ? '' : 'topic') + ..aOS(81, _omitFieldNames ? '' : 'kafkaSchemaUrl') + ..aOM<$1.Duration>(82, _omitFieldNames ? '' : 'kafkaProduceTimeout', + subBuilder: $1.Duration.create) + ..aOS(83, _omitFieldNames ? '' : 'kafkaCompression') + ..aOS(100, _omitFieldNames ? '' : 's3Endpoint') + ..aOS(101, _omitFieldNames ? '' : 's3Region') + ..aOS(102, _omitFieldNames ? '' : 's3Bucket') + ..aOS(103, _omitFieldNames ? '' : 's3Prefix') + ..aOS(104, _omitFieldNames ? '' : 's3AccessKey') + ..aOS(105, _omitFieldNames ? '' : 's3SecretKey') + ..aOB(106, _omitFieldNames ? '' : 's3SkipBucketProbe') + ..aI(110, _omitFieldNames ? '' : 's3ParquetFlushThresholdBytes', fieldType: $pb.PbFieldType.OU3) - ..aOS(186, _omitFieldNames ? '' : 'daemonVersion') - ..aI(190, _omitFieldNames ? '' : 'grpcPort', fieldType: $pb.PbFieldType.OU3) - ..aOM( - 200, _omitFieldNames ? '' : 'enabledDeserializers', - subBuilder: EnabledDeserializers.create) - ..aOB(210, _omitFieldNames ? '' : 'ioUring') - ..aI(211, _omitFieldNames ? '' : 'ioUringRecvBatchSize', + ..aOM<$1.Duration>(111, _omitFieldNames ? '' : 's3FlushInterval', + subBuilder: $1.Duration.create) + ..aI(112, _omitFieldNames ? '' : 's3FlushJitterPct', fieldType: $pb.PbFieldType.OU3) - ..aI(212, _omitFieldNames ? '' : 'ioUringCqeBatchSize', + ..aI(113, _omitFieldNames ? '' : 's3FlushThresholdJitterPct', fieldType: $pb.PbFieldType.OU3) - ..aOS(220, _omitFieldNames ? '' : 'csvColumns') - ..aI(221, _omitFieldNames ? '' : 'pollJitterPct', + ..aI(114, _omitFieldNames ? '' : 's3UploadMaxAttempts', fieldType: $pb.PbFieldType.OU3) - ..aOM<$1.Duration>(222, _omitFieldNames ? '' : 's3FlushInterval', + ..aOM<$1.Duration>(115, _omitFieldNames ? '' : 's3UploadBackoffCap', subBuilder: $1.Duration.create) - ..aI(223, _omitFieldNames ? '' : 's3FlushJitterPct', + ..aOS(130, _omitFieldNames ? '' : 'hostname') + ..aOS(131, _omitFieldNames ? '' : 'location') + ..aOS(132, _omitFieldNames ? '' : 'label') + ..aOS(133, _omitFieldNames ? '' : 'tag') + ..aOS(134, _omitFieldNames ? '' : 'daemonVersion') + ..aI(150, _omitFieldNames ? '' : 'ipv4Ttl', fieldType: $pb.PbFieldType.OU3) + ..aI(151, _omitFieldNames ? '' : 'ipv6HopLimit', fieldType: $pb.PbFieldType.OU3) - ..aI(224, _omitFieldNames ? '' : 's3FlushThresholdJitterPct', + ..aI(160, _omitFieldNames ? '' : 'grpcPort', fieldType: $pb.PbFieldType.OU3) + ..aOS(170, _omitFieldNames ? '' : 'pyroscopeUrl') + ..aOS(171, _omitFieldNames ? '' : 'pyroscopeAppName') + ..aI(172, _omitFieldNames ? '' : 'pyroscopeSampleHz', fieldType: $pb.PbFieldType.OU3) - ..aI(225, _omitFieldNames ? '' : 's3UploadMaxAttempts', + ..aI(173, _omitFieldNames ? '' : 'pyroscopeUploadIntervalSec', fieldType: $pb.PbFieldType.OU3) - ..aOM<$1.Duration>(226, _omitFieldNames ? '' : 's3UploadBackoffCap', - subBuilder: $1.Duration.create) - ..aOM<$1.Duration>(227, _omitFieldNames ? '' : 'reconcileFrequency', - subBuilder: $1.Duration.create) - ..aOB(228, _omitFieldNames ? '' : 'reconcileBeforePoll') - ..aOB(230, _omitFieldNames ? '' : 'enrichContainerEnable') - ..aOS(231, _omitFieldNames ? '' : 'dockerSocketPath') - ..aOB(232, _omitFieldNames ? '' : 'enrichLldpEnable') - ..aOS(233, _omitFieldNames ? '' : 'lldpdSocketPath') - ..aOS(234, _omitFieldNames ? '' : 'lldpdVersionHint') - ..aOB(235, _omitFieldNames ? '' : 'enrichNicEnable') - ..aI(236, _omitFieldNames ? '' : 'uplinkCount', + ..aOB(200, _omitFieldNames ? '' : 'resolveContainerId') + ..aOB(201, _omitFieldNames ? '' : 'enrichContainerEnable') + ..aOS(202, _omitFieldNames ? '' : 'dockerSocketPath') + ..aOB(210, _omitFieldNames ? '' : 'enrichLldpEnable') + ..aOS(211, _omitFieldNames ? '' : 'lldpdSocketPath') + ..aOS(212, _omitFieldNames ? '' : 'lldpdVersionHint') + ..aOB(220, _omitFieldNames ? '' : 'enrichNicEnable') + ..aI(221, _omitFieldNames ? '' : 'uplinkCount', fieldType: $pb.PbFieldType.OU3) - ..pPS(237, _omitFieldNames ? '' : 'uplinkInterfaces') - ..aOB(238, _omitFieldNames ? '' : 'populateNsid') - ..aOB(239, _omitFieldNames ? '' : 'enrichAsnEnable') - ..aOS(240, _omitFieldNames ? '' : 'asnDbPath') - ..aOM<$1.Duration>(241, _omitFieldNames ? '' : 'asnRefreshInterval', + ..pPS(222, _omitFieldNames ? '' : 'uplinkInterfaces') + ..aOB(230, _omitFieldNames ? '' : 'populateNsid') + ..aOB(240, _omitFieldNames ? '' : 'enrichAsnEnable') + ..aOS(241, _omitFieldNames ? '' : 'asnDbPath') + ..aOM<$1.Duration>(242, _omitFieldNames ? '' : 'asnRefreshInterval', subBuilder: $1.Duration.create) - ..aOB(242, _omitFieldNames ? '' : 'enrichLocalityEnable') - ..aOM<$1.Duration>(243, _omitFieldNames ? '' : 'localityRefreshInterval', + ..aOB(245, _omitFieldNames ? '' : 'enrichLocalityEnable') + ..aOM<$1.Duration>(246, _omitFieldNames ? '' : 'localityRefreshInterval', subBuilder: $1.Duration.create) ..hasRequiredFields = false; @@ -1182,142 +1201,303 @@ class XtcpConfig extends $pb.GeneratedMessage { /// This is how often xtcp sends the netlink dump request /// Recommend not too frequently, so maybe 30s or 60s /// https://pkg.go.dev/google.golang.org/protobuf/types/known/durationpb - @$pb.TagNumber(20) + @$pb.TagNumber(11) $1.Duration get pollFrequency => $_getN(1); - @$pb.TagNumber(20) - set pollFrequency($1.Duration value) => $_setField(20, value); - @$pb.TagNumber(20) + @$pb.TagNumber(11) + set pollFrequency($1.Duration value) => $_setField(11, value); + @$pb.TagNumber(11) $core.bool hasPollFrequency() => $_has(1); - @$pb.TagNumber(20) - void clearPollFrequency() => $_clearField(20); - @$pb.TagNumber(20) + @$pb.TagNumber(11) + void clearPollFrequency() => $_clearField(11); + @$pb.TagNumber(11) $1.Duration ensurePollFrequency() => $_ensure(1); /// Poll timeout per name space /// Must be less than the poll frequency - @$pb.TagNumber(30) + @$pb.TagNumber(12) $1.Duration get pollTimeout => $_getN(2); - @$pb.TagNumber(30) - set pollTimeout($1.Duration value) => $_setField(30, value); - @$pb.TagNumber(30) + @$pb.TagNumber(12) + set pollTimeout($1.Duration value) => $_setField(12, value); + @$pb.TagNumber(12) $core.bool hasPollTimeout() => $_has(2); - @$pb.TagNumber(30) - void clearPollTimeout() => $_clearField(30); - @$pb.TagNumber(30) + @$pb.TagNumber(12) + void clearPollTimeout() => $_clearField(12); + @$pb.TagNumber(12) $1.Duration ensurePollTimeout() => $_ensure(2); + /// Maximum poll-schedule jitter as a percent of poll_frequency, applied to + /// both the startup delay before the first poll and each subsequent tick. + /// 0 disables (immediate first poll, fixed interval). Default 20. See + /// docs/design-jitter-and-backoff.md. + @$pb.TagNumber(13) + $core.int get pollJitterPct => $_getIZ(3); + @$pb.TagNumber(13) + set pollJitterPct($core.int value) => $_setUnsignedInt32(3, value); + @$pb.TagNumber(13) + $core.bool hasPollJitterPct() => $_has(3); + @$pb.TagNumber(13) + void clearPollJitterPct() => $_clearField(13); + /// Maximum number of loops, or zero (0) for forever - @$pb.TagNumber(40) - $fixnum.Int64 get maxLoops => $_getI64(3); - @$pb.TagNumber(40) - set maxLoops($fixnum.Int64 value) => $_setInt64(3, value); - @$pb.TagNumber(40) - $core.bool hasMaxLoops() => $_has(3); - @$pb.TagNumber(40) - void clearMaxLoops() => $_clearField(40); + @$pb.TagNumber(14) + $fixnum.Int64 get maxLoops => $_getI64(4); + @$pb.TagNumber(14) + set maxLoops($fixnum.Int64 value) => $_setInt64(4, value); + @$pb.TagNumber(14) + $core.bool hasMaxLoops() => $_has(4); + @$pb.TagNumber(14) + void clearMaxLoops() => $_clearField(14); /// Netlinker goroutines per netlink socket ( recommend 1,2,4 range ) /// Netlinkers read the tcp-diag response messages from the netlink socket /// If you have a large number of - @$pb.TagNumber(50) - $core.int get netlinkers => $_getIZ(4); - @$pb.TagNumber(50) - set netlinkers($core.int value) => $_setUnsignedInt32(4, value); - @$pb.TagNumber(50) - $core.bool hasNetlinkers() => $_has(4); - @$pb.TagNumber(50) - void clearNetlinkers() => $_clearField(50); + @$pb.TagNumber(15) + $core.int get netlinkers => $_getIZ(5); + @$pb.TagNumber(15) + set netlinkers($core.int value) => $_setUnsignedInt32(5, value); + @$pb.TagNumber(15) + $core.bool hasNetlinkers() => $_has(5); + @$pb.TagNumber(15) + void clearNetlinkers() => $_clearField(15); /// netlinkerDoneCh channel size /// This channel is used between the netlinkers and the poller /// Check the prom counter to see if the channel is too small /// d.pC.WithLabelValues("Deserialize", "netlinkerDoneCh", "error").Inc() - @$pb.TagNumber(51) - $core.int get netlinkersDoneChanSize => $_getIZ(5); - @$pb.TagNumber(51) - set netlinkersDoneChanSize($core.int value) => $_setUnsignedInt32(5, value); - @$pb.TagNumber(51) - $core.bool hasNetlinkersDoneChanSize() => $_has(5); - @$pb.TagNumber(51) - void clearNetlinkersDoneChanSize() => $_clearField(51); + @$pb.TagNumber(16) + $core.int get netlinkersDoneChanSize => $_getIZ(6); + @$pb.TagNumber(16) + set netlinkersDoneChanSize($core.int value) => $_setUnsignedInt32(6, value); + @$pb.TagNumber(16) + $core.bool hasNetlinkersDoneChanSize() => $_has(6); + @$pb.TagNumber(16) + void clearNetlinkersDoneChanSize() => $_clearField(16); /// nlmsg_seq sequence number (start). This gets incremented. - @$pb.TagNumber(60) - $core.int get nlmsgSeq => $_getIZ(6); - @$pb.TagNumber(60) - set nlmsgSeq($core.int value) => $_setUnsignedInt32(6, value); - @$pb.TagNumber(60) - $core.bool hasNlmsgSeq() => $_has(6); - @$pb.TagNumber(60) - void clearNlmsgSeq() => $_clearField(60); + @$pb.TagNumber(17) + $core.int get nlmsgSeq => $_getIZ(7); + @$pb.TagNumber(17) + set nlmsgSeq($core.int value) => $_setUnsignedInt32(7, value); + @$pb.TagNumber(17) + $core.bool hasNlmsgSeq() => $_has(7); + @$pb.TagNumber(17) + void clearNlmsgSeq() => $_clearField(17); /// netlinker packetSize. buffer size = packetSize * packetSizeMply. Use zero (0) for syscall.Getpagesize() /// recommend using 0 - @$pb.TagNumber(70) - $fixnum.Int64 get packetSize => $_getI64(7); - @$pb.TagNumber(70) - set packetSize($fixnum.Int64 value) => $_setInt64(7, value); - @$pb.TagNumber(70) - $core.bool hasPacketSize() => $_has(7); - @$pb.TagNumber(70) - void clearPacketSize() => $_clearField(70); + @$pb.TagNumber(18) + $fixnum.Int64 get packetSize => $_getI64(8); + @$pb.TagNumber(18) + set packetSize($fixnum.Int64 value) => $_setInt64(8, value); + @$pb.TagNumber(18) + $core.bool hasPacketSize() => $_has(8); + @$pb.TagNumber(18) + void clearPacketSize() => $_clearField(18); /// netlinker packetSize multiplier. buffer size = packetSize * packetSizeMply - @$pb.TagNumber(80) - $core.int get packetSizeMply => $_getIZ(8); - @$pb.TagNumber(80) - set packetSizeMply($core.int value) => $_setUnsignedInt32(8, value); - @$pb.TagNumber(80) - $core.bool hasPacketSizeMply() => $_has(8); - @$pb.TagNumber(80) - void clearPacketSizeMply() => $_clearField(80); + @$pb.TagNumber(19) + $core.int get packetSizeMply => $_getIZ(9); + @$pb.TagNumber(19) + set packetSizeMply($core.int value) => $_setUnsignedInt32(9, value); + @$pb.TagNumber(19) + $core.bool hasPacketSizeMply() => $_has(9); + @$pb.TagNumber(19) + void clearPacketSizeMply() => $_clearField(19); + + /// modulus. Report every X socket diag messages to output + @$pb.TagNumber(20) + $fixnum.Int64 get modulus => $_getI64(10); + @$pb.TagNumber(20) + set modulus($fixnum.Int64 value) => $_setInt64(10, value); + @$pb.TagNumber(20) + $core.bool hasModulus() => $_has(10); + @$pb.TagNumber(20) + void clearModulus() => $_clearField(20); + + /// Which INET_DIAG_* extension deserializers run (keyed by short name: + /// info, skmem, cong, tos, tc, shut, vegas, dctcp, bbr, classid, sockopt, + /// cgroup, meminfo). Unset = daemon defaults. + @$pb.TagNumber(21) + EnabledDeserializers get enabledDeserializers => $_getN(11); + @$pb.TagNumber(21) + set enabledDeserializers(EnabledDeserializers value) => $_setField(21, value); + @$pb.TagNumber(21) + $core.bool hasEnabledDeserializers() => $_has(11); + @$pb.TagNumber(21) + void clearEnabledDeserializers() => $_clearField(21); + @$pb.TagNumber(21) + EnabledDeserializers ensureEnabledDeserializers() => $_ensure(11); + + /// When true, route netlink reads and raw-socket destination writes + /// through an io_uring ring per Netlinker. Requires Linux 6.1+. + /// Library-backed destinations (kafka, nsq, nats, valkey) ignore this + /// flag — they continue to use their own client sockets unchanged. + @$pb.TagNumber(22) + $core.bool get ioUring => $_getBF(12); + @$pb.TagNumber(22) + set ioUring($core.bool value) => $_setBool(12, value); + @$pb.TagNumber(22) + $core.bool hasIoUring() => $_has(12); + @$pb.TagNumber(22) + void clearIoUring() => $_clearField(22); + + /// Number of recvmsg SQEs kept in flight per Netlinker ring. Higher + /// values reduce io_uring_enter syscalls per dump cycle on hosts with + /// many sockets, at the cost of more pinned buffers from packet pool. + /// Ignored unless io_uring=true. Default 64. + @$pb.TagNumber(23) + $core.int get ioUringRecvBatchSize => $_getIZ(13); + @$pb.TagNumber(23) + set ioUringRecvBatchSize($core.int value) => $_setUnsignedInt32(13, value); + @$pb.TagNumber(23) + $core.bool hasIoUringRecvBatchSize() => $_has(13); + @$pb.TagNumber(23) + void clearIoUringRecvBatchSize() => $_clearField(23); + + /// Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise + /// userland loop overhead but increase scheduling latency for the + /// netlinker goroutine. Ignored unless io_uring=true. Default 128. + @$pb.TagNumber(24) + $core.int get ioUringCqeBatchSize => $_getIZ(14); + @$pb.TagNumber(24) + set ioUringCqeBatchSize($core.int value) => $_setUnsignedInt32(14, value); + @$pb.TagNumber(24) + $core.bool hasIoUringCqeBatchSize() => $_has(14); + @$pb.TagNumber(24) + void clearIoUringCqeBatchSize() => $_clearField(24); + + /// Period of the background namespace-reconcile ticker (Method B /proc scan + /// that converges the tracked namespace set). With reconcile_before_poll the + /// Poller reconciles every cycle and is the real discovery mechanism, so this + /// background pass is an occasional safety-net expected to find nothing + /// (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) + /// so operators can confirm from the counters that it is redundant. It still + /// matters when the poller is idle or disabled. 0 disables the background + /// ticker entirely (the startup reconcile still runs once). + @$pb.TagNumber(40) + $1.Duration get reconcileFrequency => $_getN(15); + @$pb.TagNumber(40) + set reconcileFrequency($1.Duration value) => $_setField(40, value); + @$pb.TagNumber(40) + $core.bool hasReconcileFrequency() => $_has(15); + @$pb.TagNumber(40) + void clearReconcileFrequency() => $_clearField(40); + @$pb.TagNumber(40) + $1.Duration ensureReconcileFrequency() => $_ensure(15); + + /// Run a namespace reconcile immediately before each poll cycle, so a + /// namespace that appeared since the last cycle is entered and gets a socket + /// within ~1 poll interval instead of waiting for the background ticker. Ties + /// discovery cadence to poll cadence; the /proc scan is zero-allocation and + /// mutex-serialized with the background reconciler. Default true. + @$pb.TagNumber(41) + $core.bool get reconcileBeforePoll => $_getBF(16); + @$pb.TagNumber(41) + set reconcileBeforePoll($core.bool value) => $_setBool(16, value); + @$pb.TagNumber(41) + $core.bool hasReconcileBeforePoll() => $_has(16); + @$pb.TagNumber(41) + void clearReconcileBeforePoll() => $_clearField(41); /// Write netlink packets to writeFiles number of files ( to generate test data ) per netlinker /// xtcp will capture this many Netlink response packets when it starts /// This is PER netlinker - @$pb.TagNumber(90) - $core.int get writeFiles => $_getIZ(9); - @$pb.TagNumber(90) - set writeFiles($core.int value) => $_setUnsignedInt32(9, value); - @$pb.TagNumber(90) - $core.bool hasWriteFiles() => $_has(9); - @$pb.TagNumber(90) - void clearWriteFiles() => $_clearField(90); + @$pb.TagNumber(50) + $core.int get writeFiles => $_getIZ(17); + @$pb.TagNumber(50) + set writeFiles($core.int value) => $_setUnsignedInt32(17, value); + @$pb.TagNumber(50) + $core.bool hasWriteFiles() => $_has(17); + @$pb.TagNumber(50) + void clearWriteFiles() => $_clearField(50); /// Write files path - @$pb.TagNumber(100) - $core.String get capturePath => $_getSZ(10); - @$pb.TagNumber(100) - set capturePath($core.String value) => $_setString(10, value); - @$pb.TagNumber(100) - $core.bool hasCapturePath() => $_has(10); - @$pb.TagNumber(100) - void clearCapturePath() => $_clearField(100); + @$pb.TagNumber(51) + $core.String get capturePath => $_getSZ(18); + @$pb.TagNumber(51) + set capturePath($core.String value) => $_setString(18, value); + @$pb.TagNumber(51) + $core.bool hasCapturePath() => $_has(18); + @$pb.TagNumber(51) + void clearCapturePath() => $_clearField(51); - /// modulus. Report every X socket diag messages to output - @$pb.TagNumber(110) - $fixnum.Int64 get modulus => $_getI64(11); - @$pb.TagNumber(110) - set modulus($fixnum.Int64 value) => $_setInt64(11, value); - @$pb.TagNumber(110) - $core.bool hasModulus() => $_has(11); - @$pb.TagNumber(110) - void clearModulus() => $_clearField(110); + /// Write marshalled data to dest_write_files number of files ( to allow debugging of the serialization ) + /// xtcp will capture this many examples of the marshalled data + /// This is PER poller + @$pb.TagNumber(52) + $core.int get destWriteFiles => $_getIZ(19); + @$pb.TagNumber(52) + set destWriteFiles($core.int value) => $_setUnsignedInt32(19, value); + @$pb.TagNumber(52) + $core.bool hasDestWriteFiles() => $_has(19); + @$pb.TagNumber(52) + void clearDestWriteFiles() => $_clearField(52); - /// Marshalling of the exported data (protobufList,json,prototext) - @$pb.TagNumber(120) - $core.String get marshalTo => $_getSZ(12); - @$pb.TagNumber(120) - set marshalTo($core.String value) => $_setString(12, value); - @$pb.TagNumber(120) - $core.bool hasMarshalTo() => $_has(12); - @$pb.TagNumber(120) - void clearMarshalTo() => $_clearField(120); + /// DebugLevel + @$pb.TagNumber(53) + $core.int get debugLevel => $_getIZ(20); + @$pb.TagNumber(53) + set debugLevel($core.int value) => $_setUnsignedInt32(20, value); + @$pb.TagNumber(53) + $core.bool hasDebugLevel() => $_has(20); + @$pb.TagNumber(53) + void clearDebugLevel() => $_clearField(53); - /// Soft cap on the in-flight envelope's marshalled size, in bytes. - /// Measured via proto.Size — i.e. the UNCOMPRESSED serialized size. - /// franz-go applies ZSTD/LZ4/Snappy compression after handoff, so the - /// actual on-wire Kafka message is typically 3-8x smaller than the + /// kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, + /// nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, + /// unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or + /// unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). + /// max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the + /// http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES + /// and S3 endpoints the INSERT query + FORMAT + format_schema + auth query + /// params routinely run ~150+ chars, which the old 128 cap rejected. + @$pb.TagNumber(60) + $core.String get dest => $_getSZ(21); + @$pb.TagNumber(60) + set dest($core.String value) => $_setString(21, value); + @$pb.TagNumber(60) + $core.bool hasDest() => $_has(21); + @$pb.TagNumber(60) + void clearDest() => $_clearField(60); + + /// Marshalling of the exported data (protobufList,json,prototext) + @$pb.TagNumber(61) + $core.String get marshalTo => $_getSZ(22); + @$pb.TagNumber(61) + set marshalTo($core.String value) => $_setString(22, value); + @$pb.TagNumber(61) + $core.bool hasMarshalTo() => $_has(22); + @$pb.TagNumber(61) + void clearMarshalTo() => $_clearField(61); + + /// Comma-separated subset of XtcpFlatRecord json field names selecting + /// which columns the csv/tsv marshallers emit (e.g. + /// "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). + /// Empty = all fields. Ignored by non-tabular marshallers. + @$pb.TagNumber(62) + $core.String get csvColumns => $_getSZ(23); + @$pb.TagNumber(62) + set csvColumns($core.String value) => $_setString(23, value); + @$pb.TagNumber(62) + $core.bool hasCsvColumns() => $_has(23); + @$pb.TagNumber(62) + void clearCsvColumns() => $_clearField(62); + + /// XtcpProtoFile — path of the xtcp_flat_record.proto the daemon reads at + /// startup and POSTs to the Kafka schema registry (kafka_schema_url). + @$pb.TagNumber(63) + $core.String get xtcpProtoFile => $_getSZ(24); + @$pb.TagNumber(63) + set xtcpProtoFile($core.String value) => $_setString(24, value); + @$pb.TagNumber(63) + $core.bool hasXtcpProtoFile() => $_has(24); + @$pb.TagNumber(63) + void clearXtcpProtoFile() => $_clearField(63); + + /// Soft cap on the in-flight envelope's marshalled size, in bytes. + /// Measured via proto.Size — i.e. the UNCOMPRESSED serialized size. + /// franz-go applies ZSTD/LZ4/Snappy compression after handoff, so the + /// actual on-wire Kafka message is typically 3-8x smaller than the /// proto.Size we measure here. Treat this as a conservative upper /// bound, not the wire size. /// @@ -1326,15 +1506,15 @@ class XtcpConfig extends $pb.GeneratedMessage { /// Useful primarily as a safety net against records with huge /// `bytes` fields. For everyday batch sizing, prefer the row-count /// cap (envelope_flush_threshold_rows) below. - @$pb.TagNumber(122) - $core.int get envelopeFlushThresholdBytes => $_getIZ(13); - @$pb.TagNumber(122) + @$pb.TagNumber(64) + $core.int get envelopeFlushThresholdBytes => $_getIZ(25); + @$pb.TagNumber(64) set envelopeFlushThresholdBytes($core.int value) => - $_setUnsignedInt32(13, value); - @$pb.TagNumber(122) - $core.bool hasEnvelopeFlushThresholdBytes() => $_has(13); - @$pb.TagNumber(122) - void clearEnvelopeFlushThresholdBytes() => $_clearField(122); + $_setUnsignedInt32(25, value); + @$pb.TagNumber(64) + $core.bool hasEnvelopeFlushThresholdBytes() => $_has(25); + @$pb.TagNumber(64) + void clearEnvelopeFlushThresholdBytes() => $_clearField(64); /// Soft cap on the in-flight envelope's row count. When the envelope /// reaches this many rows, deserialize.go triggers an early mid-poll @@ -1346,15 +1526,49 @@ class XtcpConfig extends $pb.GeneratedMessage { /// (EnvelopeFlushThresholdRowsCst, currently 10000 — chosen to align /// with the ClickHouse kafka_max_rows_per_message setting so a /// produced envelope never forces the consumer to split it). - @$pb.TagNumber(123) - $core.int get envelopeFlushThresholdRows => $_getIZ(14); - @$pb.TagNumber(123) + @$pb.TagNumber(65) + $core.int get envelopeFlushThresholdRows => $_getIZ(26); + @$pb.TagNumber(65) set envelopeFlushThresholdRows($core.int value) => - $_setUnsignedInt32(14, value); - @$pb.TagNumber(123) - $core.bool hasEnvelopeFlushThresholdRows() => $_has(14); - @$pb.TagNumber(123) - void clearEnvelopeFlushThresholdRows() => $_clearField(123); + $_setUnsignedInt32(26, value); + @$pb.TagNumber(65) + $core.bool hasEnvelopeFlushThresholdRows() => $_has(26); + @$pb.TagNumber(65) + void clearEnvelopeFlushThresholdRows() => $_clearField(65); + + /// Kafka or NSQ topic + @$pb.TagNumber(80) + $core.String get topic => $_getSZ(27); + @$pb.TagNumber(80) + set topic($core.String value) => $_setString(27, value); + @$pb.TagNumber(80) + $core.bool hasTopic() => $_has(27); + @$pb.TagNumber(80) + void clearTopic() => $_clearField(80); + + /// Kafka schema registry url + @$pb.TagNumber(81) + $core.String get kafkaSchemaUrl => $_getSZ(28); + @$pb.TagNumber(81) + set kafkaSchemaUrl($core.String value) => $_setString(28, value); + @$pb.TagNumber(81) + $core.bool hasKafkaSchemaUrl() => $_has(28); + @$pb.TagNumber(81) + void clearKafkaSchemaUrl() => $_clearField(81); + + /// Kafka Produce context timeout. Use 0 for no context timeout + /// Recommend a small timeout, like 1-2 seconds + /// kgo seems to have a bug, because the timeout is always expired + @$pb.TagNumber(82) + $1.Duration get kafkaProduceTimeout => $_getN(29); + @$pb.TagNumber(82) + set kafkaProduceTimeout($1.Duration value) => $_setField(82, value); + @$pb.TagNumber(82) + $core.bool hasKafkaProduceTimeout() => $_has(29); + @$pb.TagNumber(82) + void clearKafkaProduceTimeout() => $_clearField(82); + @$pb.TagNumber(82) + $1.Duration ensureKafkaProduceTimeout() => $_ensure(29); /// Kafka producer-batch compression codec. franz-go picks one codec /// from the supplied preference list that the broker advertises. @@ -1374,88 +1588,97 @@ class XtcpConfig extends $pb.GeneratedMessage { /// /// Pick "lz4" if xtcp2 is CPU-bound on the producer side; pick /// "zstd" (the default) if Kafka throughput / disk usage matters more. - @$pb.TagNumber(124) - $core.String get kafkaCompression => $_getSZ(15); - @$pb.TagNumber(124) - set kafkaCompression($core.String value) => $_setString(15, value); - @$pb.TagNumber(124) - $core.bool hasKafkaCompression() => $_has(15); - @$pb.TagNumber(124) - void clearKafkaCompression() => $_clearField(124); + @$pb.TagNumber(83) + $core.String get kafkaCompression => $_getSZ(30); + @$pb.TagNumber(83) + set kafkaCompression($core.String value) => $_setString(30, value); + @$pb.TagNumber(83) + $core.bool hasKafkaCompression() => $_has(30); + @$pb.TagNumber(83) + void clearKafkaCompression() => $_clearField(83); /// S3 endpoint URL, e.g. "http://127.0.0.1:9000" (MinIO) or /// "https://s3.amazonaws.com" (AWS). May be empty if -dest carries /// it via the s3parquet: form. - @$pb.TagNumber(125) - $core.String get s3Endpoint => $_getSZ(16); - @$pb.TagNumber(125) - set s3Endpoint($core.String value) => $_setString(16, value); - @$pb.TagNumber(125) - $core.bool hasS3Endpoint() => $_has(16); - @$pb.TagNumber(125) - void clearS3Endpoint() => $_clearField(125); + @$pb.TagNumber(100) + $core.String get s3Endpoint => $_getSZ(31); + @$pb.TagNumber(100) + set s3Endpoint($core.String value) => $_setString(31, value); + @$pb.TagNumber(100) + $core.bool hasS3Endpoint() => $_has(31); + @$pb.TagNumber(100) + void clearS3Endpoint() => $_clearField(100); + + /// S3 region. Required by some S3 implementations even when talking + /// to a single-region MinIO. Default "us-east-1" when blank. + @$pb.TagNumber(101) + $core.String get s3Region => $_getSZ(32); + @$pb.TagNumber(101) + set s3Region($core.String value) => $_setString(32, value); + @$pb.TagNumber(101) + $core.bool hasS3Region() => $_has(32); + @$pb.TagNumber(101) + void clearS3Region() => $_clearField(101); /// Required when -dest s3parquet. Bucket must already exist on the /// endpoint; the daemon does not auto-create. - @$pb.TagNumber(126) - $core.String get s3Bucket => $_getSZ(17); - @$pb.TagNumber(126) - set s3Bucket($core.String value) => $_setString(17, value); - @$pb.TagNumber(126) - $core.bool hasS3Bucket() => $_has(17); - @$pb.TagNumber(126) - void clearS3Bucket() => $_clearField(126); + @$pb.TagNumber(102) + $core.String get s3Bucket => $_getSZ(33); + @$pb.TagNumber(102) + set s3Bucket($core.String value) => $_setString(33, value); + @$pb.TagNumber(102) + $core.bool hasS3Bucket() => $_has(33); + @$pb.TagNumber(102) + void clearS3Bucket() => $_clearField(102); /// Optional key-prefix WITHIN the bucket. Joined with the Hive-style /// partition segments (host=…/date=…/hour=…/.parquet). Empty /// = files land at the bucket root level. - @$pb.TagNumber(127) - $core.String get s3Prefix => $_getSZ(18); - @$pb.TagNumber(127) - set s3Prefix($core.String value) => $_setString(18, value); - @$pb.TagNumber(127) - $core.bool hasS3Prefix() => $_has(18); - @$pb.TagNumber(127) - void clearS3Prefix() => $_clearField(127); + @$pb.TagNumber(103) + $core.String get s3Prefix => $_getSZ(34); + @$pb.TagNumber(103) + set s3Prefix($core.String value) => $_setString(34, value); + @$pb.TagNumber(103) + $core.bool hasS3Prefix() => $_has(34); + @$pb.TagNumber(103) + void clearS3Prefix() => $_clearField(103); /// Required when -dest s3parquet. Picked up from AWS_ACCESS_KEY_ID /// env if blank. - @$pb.TagNumber(128) - $core.String get s3AccessKey => $_getSZ(19); - @$pb.TagNumber(128) - set s3AccessKey($core.String value) => $_setString(19, value); - @$pb.TagNumber(128) - $core.bool hasS3AccessKey() => $_has(19); - @$pb.TagNumber(128) - void clearS3AccessKey() => $_clearField(128); + @$pb.TagNumber(104) + $core.String get s3AccessKey => $_getSZ(35); + @$pb.TagNumber(104) + set s3AccessKey($core.String value) => $_setString(35, value); + @$pb.TagNumber(104) + $core.bool hasS3AccessKey() => $_has(35); + @$pb.TagNumber(104) + void clearS3AccessKey() => $_clearField(104); /// Required when -dest s3parquet. Picked up from AWS_SECRET_ACCESS_KEY /// env if blank. Never logged. - @$pb.TagNumber(129) - $core.String get s3SecretKey => $_getSZ(20); - @$pb.TagNumber(129) - set s3SecretKey($core.String value) => $_setString(20, value); - @$pb.TagNumber(129) - $core.bool hasS3SecretKey() => $_has(20); - @$pb.TagNumber(129) - void clearS3SecretKey() => $_clearField(129); + @$pb.TagNumber(105) + $core.String get s3SecretKey => $_getSZ(36); + @$pb.TagNumber(105) + set s3SecretKey($core.String value) => $_setString(36, value); + @$pb.TagNumber(105) + $core.bool hasS3SecretKey() => $_has(36); + @$pb.TagNumber(105) + void clearS3SecretKey() => $_clearField(105); - /// kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, - /// nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, - /// unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or - /// unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). - /// max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the - /// http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES - /// and S3 endpoints the INSERT query + FORMAT + format_schema + auth query - /// params routinely run ~150+ chars, which the old 128 cap rejected. - @$pb.TagNumber(130) - $core.String get dest => $_getSZ(21); - @$pb.TagNumber(130) - set dest($core.String value) => $_setString(21, value); - @$pb.TagNumber(130) - $core.bool hasDest() => $_has(21); - @$pb.TagNumber(130) - void clearDest() => $_clearField(130); + /// Skip the startup S3 BucketExists probe. The probe issues a + /// HeadBucket, which requires the s3:ListBucket permission. Set true + /// when the upload credential is deliberately scoped to s3:PutObject + /// only (write-only key, e.g. a baked deployment credential) so the + /// daemon can start without list permission. Default false keeps the + /// fail-fast probe for normal deployments. + @$pb.TagNumber(106) + $core.bool get s3SkipBucketProbe => $_getBF(37); + @$pb.TagNumber(106) + set s3SkipBucketProbe($core.bool value) => $_setBool(37, value); + @$pb.TagNumber(106) + $core.bool hasS3SkipBucketProbe() => $_has(37); + @$pb.TagNumber(106) + void clearS3SkipBucketProbe() => $_clearField(106); /// Soft cap on the in-memory Parquet builder's accumulated /// uncompressed row bytes before the worker finalizes the file and @@ -1463,53 +1686,174 @@ class XtcpConfig extends $pb.GeneratedMessage { /// Operators tune down for faster file rotation (more S3 PUTs, /// smaller per-file query latency) or up for fewer larger files /// (better compression ratio, more memory). + @$pb.TagNumber(110) + $core.int get s3ParquetFlushThresholdBytes => $_getIZ(38); + @$pb.TagNumber(110) + set s3ParquetFlushThresholdBytes($core.int value) => + $_setUnsignedInt32(38, value); + @$pb.TagNumber(110) + $core.bool hasS3ParquetFlushThresholdBytes() => $_has(38); + @$pb.TagNumber(110) + void clearS3ParquetFlushThresholdBytes() => $_clearField(110); + + /// s3parquet staleness ceiling: force-flush the in-memory Parquet object + /// after this long even if it hasn't reached the byte cap, bounding upload + /// latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). + @$pb.TagNumber(111) + $1.Duration get s3FlushInterval => $_getN(39); + @$pb.TagNumber(111) + set s3FlushInterval($1.Duration value) => $_setField(111, value); + @$pb.TagNumber(111) + $core.bool hasS3FlushInterval() => $_has(39); + @$pb.TagNumber(111) + void clearS3FlushInterval() => $_clearField(111); + @$pb.TagNumber(111) + $1.Duration ensureS3FlushInterval() => $_ensure(39); + + /// Maximum jitter as a percent of s3_flush_interval, applied to the first + /// timed flush and each interval so the fleet doesn't ceiling-flush in + /// lockstep. 0 disables. Default 20. + @$pb.TagNumber(112) + $core.int get s3FlushJitterPct => $_getIZ(40); + @$pb.TagNumber(112) + set s3FlushJitterPct($core.int value) => $_setUnsignedInt32(40, value); + @$pb.TagNumber(112) + $core.bool hasS3FlushJitterPct() => $_has(40); + @$pb.TagNumber(112) + void clearS3FlushJitterPct() => $_clearField(112); + + /// Per-object downward jitter as a percent of the s3parquet byte cap: each + /// object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the + /// size-cap upload path even under uniform load. Downward-only, so an + /// object never exceeds the in-memory byte bound. 0 disables. Default 20. + @$pb.TagNumber(113) + $core.int get s3FlushThresholdJitterPct => $_getIZ(41); + @$pb.TagNumber(113) + set s3FlushThresholdJitterPct($core.int value) => + $_setUnsignedInt32(41, value); + @$pb.TagNumber(113) + $core.bool hasS3FlushThresholdJitterPct() => $_has(41); + @$pb.TagNumber(113) + void clearS3FlushThresholdJitterPct() => $_clearField(113); + + /// Maximum S3 upload attempts (original + retries) before dropping the + /// object. Retries use full-jitter exponential backoff. Default 10. + @$pb.TagNumber(114) + $core.int get s3UploadMaxAttempts => $_getIZ(42); + @$pb.TagNumber(114) + set s3UploadMaxAttempts($core.int value) => $_setUnsignedInt32(42, value); + @$pb.TagNumber(114) + $core.bool hasS3UploadMaxAttempts() => $_has(42); + @$pb.TagNumber(114) + void clearS3UploadMaxAttempts() => $_clearField(114); + + /// Cap on a single upload retry's backoff window (full jitter draws in + /// [0, window], window grows exponentially up to this cap). 0 = derive as + /// clamp(poll_frequency/10, 1s, 1h). + @$pb.TagNumber(115) + $1.Duration get s3UploadBackoffCap => $_getN(43); + @$pb.TagNumber(115) + set s3UploadBackoffCap($1.Duration value) => $_setField(115, value); + @$pb.TagNumber(115) + $core.bool hasS3UploadBackoffCap() => $_has(43); + @$pb.TagNumber(115) + void clearS3UploadBackoffCap() => $_clearField(115); + @$pb.TagNumber(115) + $1.Duration ensureS3UploadBackoffCap() => $_ensure(43); + + /// Hostname override. When empty the daemon uses os.Hostname(); set this to + /// stamp an explicit hostname on records — required in containers, where + /// os.Hostname() returns the container id, not the host. Set via -hostname + /// flag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the + /// container id). + @$pb.TagNumber(130) + $core.String get hostname => $_getSZ(44); + @$pb.TagNumber(130) + set hostname($core.String value) => $_setString(44, value); + @$pb.TagNumber(130) + $core.bool hasHostname() => $_has(44); + @$pb.TagNumber(130) + void clearHostname() => $_clearField(130); + + /// Deployment grouping / facility this daemon runs in (data center, PoP, + /// region, site, …). Generic; stamped on every record's `location` field. + /// Set via -location flag or LOCATION env. + @$pb.TagNumber(131) + $core.String get location => $_getSZ(45); + @$pb.TagNumber(131) + set location($core.String value) => $_setString(45, value); + @$pb.TagNumber(131) + $core.bool hasLocation() => $_has(45); + @$pb.TagNumber(131) + void clearLocation() => $_clearField(131); + + /// Label applied to the protobuf @$pb.TagNumber(132) - $core.int get s3ParquetFlushThresholdBytes => $_getIZ(22); + $core.String get label => $_getSZ(46); @$pb.TagNumber(132) - set s3ParquetFlushThresholdBytes($core.int value) => - $_setUnsignedInt32(22, value); + set label($core.String value) => $_setString(46, value); @$pb.TagNumber(132) - $core.bool hasS3ParquetFlushThresholdBytes() => $_has(22); + $core.bool hasLabel() => $_has(46); @$pb.TagNumber(132) - void clearS3ParquetFlushThresholdBytes() => $_clearField(132); + void clearLabel() => $_clearField(132); - /// S3 region. Required by some S3 implementations even when talking - /// to a single-region MinIO. Default "us-east-1" when blank. + /// Tag applied to the protobuf @$pb.TagNumber(133) - $core.String get s3Region => $_getSZ(23); + $core.String get tag => $_getSZ(47); @$pb.TagNumber(133) - set s3Region($core.String value) => $_setString(23, value); + set tag($core.String value) => $_setString(47, value); @$pb.TagNumber(133) - $core.bool hasS3Region() => $_has(23); + $core.bool hasTag() => $_has(47); @$pb.TagNumber(133) - void clearS3Region() => $_clearField(133); + void clearTag() => $_clearField(133); - /// Skip the startup S3 BucketExists probe. The probe issues a - /// HeadBucket, which requires the s3:ListBucket permission. Set true - /// when the upload credential is deliberately scoped to s3:PutObject - /// only (write-only key, e.g. a baked deployment credential) so the - /// daemon can start without list permission. Default false keeps the - /// fail-fast probe for normal deployments. + /// Daemon build provenance stamped on every record's `daemon_version` field + /// (git commit / date / version). Populated by the daemon from -ldflags build + /// vars, not a user flag; informational only (debugging which binary produced a + /// row). See XtcpFlatRecord.daemon_version. @$pb.TagNumber(134) - $core.bool get s3SkipBucketProbe => $_getBF(24); + $core.String get daemonVersion => $_getSZ(48); @$pb.TagNumber(134) - set s3SkipBucketProbe($core.bool value) => $_setBool(24, value); + set daemonVersion($core.String value) => $_setString(48, value); @$pb.TagNumber(134) - $core.bool hasS3SkipBucketProbe() => $_has(24); + $core.bool hasDaemonVersion() => $_has(48); @$pb.TagNumber(134) - void clearS3SkipBucketProbe() => $_clearField(134); + void clearDaemonVersion() => $_clearField(134); - /// Write marhselled data to writeFiles number of files ( to allow debugging of the serialization ) - /// xtcp will capture this many examples of the marshalled data - /// This is PER poller - @$pb.TagNumber(135) - $core.int get destWriteFiles => $_getIZ(25); - @$pb.TagNumber(135) - set destWriteFiles($core.int value) => $_setUnsignedInt32(25, value); - @$pb.TagNumber(135) - $core.bool hasDestWriteFiles() => $_has(25); - @$pb.TagNumber(135) - void clearDestWriteFiles() => $_clearField(135); + /// Outgoing IPv4 TTL for xtcp2's own TCP listeners (Prometheus + gRPC). + /// 0 = kernel default. A low value (e.g. 3) keeps replies from travelling + /// far if the host is unexpectedly internet-exposed — the per-listener + /// analogue of the host nftables TTL clamp. Set via -ipv4Ttl / IPV4_TTL. + /// (cf. prometheus/exporter-toolkit#396.) + @$pb.TagNumber(150) + $core.int get ipv4Ttl => $_getIZ(49); + @$pb.TagNumber(150) + set ipv4Ttl($core.int value) => $_setUnsignedInt32(49, value); + @$pb.TagNumber(150) + $core.bool hasIpv4Ttl() => $_has(49); + @$pb.TagNumber(150) + void clearIpv4Ttl() => $_clearField(150); + + /// Outgoing IPv6 unicast hop limit for xtcp2's own TCP listeners. 0 = kernel + /// default. Same intent as ipv4_ttl. Set via -ipv6HopLimit / IPV6_HOP_LIMIT. + @$pb.TagNumber(151) + $core.int get ipv6HopLimit => $_getIZ(50); + @$pb.TagNumber(151) + set ipv6HopLimit($core.int value) => $_setUnsignedInt32(50, value); + @$pb.TagNumber(151) + $core.bool hasIpv6HopLimit() => $_has(50); + @$pb.TagNumber(151) + void clearIpv6HopLimit() => $_clearField(151); + + /// GRPC listening port + @$pb.TagNumber(160) + $core.int get grpcPort => $_getIZ(51); + @$pb.TagNumber(160) + set grpcPort($core.int value) => $_setUnsignedInt32(51, value); + @$pb.TagNumber(160) + $core.bool hasGrpcPort() => $_has(51); + @$pb.TagNumber(160) + void clearGrpcPort() => $_clearField(160); /// Pyroscope continuous-profiling server URL (e.g. /// http://127.0.0.1:4040). When set, the daemon streams CPU, @@ -1518,542 +1862,229 @@ class XtcpConfig extends $pb.GeneratedMessage { /// don't need it. Operators bring up a Pyroscope OSS server (or /// Grafana Cloud Pyroscope) and point xtcp2 at it for live profile /// data without restarts. - @$pb.TagNumber(136) - $core.String get pyroscopeUrl => $_getSZ(26); - @$pb.TagNumber(136) - set pyroscopeUrl($core.String value) => $_setString(26, value); - @$pb.TagNumber(136) - $core.bool hasPyroscopeUrl() => $_has(26); - @$pb.TagNumber(136) - void clearPyroscopeUrl() => $_clearField(136); + @$pb.TagNumber(170) + $core.String get pyroscopeUrl => $_getSZ(52); + @$pb.TagNumber(170) + set pyroscopeUrl($core.String value) => $_setString(52, value); + @$pb.TagNumber(170) + $core.bool hasPyroscopeUrl() => $_has(52); + @$pb.TagNumber(170) + void clearPyroscopeUrl() => $_clearField(170); /// Application name registered with the Pyroscope server (the /// "application" facet in the Pyroscope UI). Empty → "xtcp2". /// Set per fleet/role for multi-host environments /// (e.g. "xtcp2.prod.iad", "xtcp2.staging.fra"). - @$pb.TagNumber(137) - $core.String get pyroscopeAppName => $_getSZ(27); - @$pb.TagNumber(137) - set pyroscopeAppName($core.String value) => $_setString(27, value); - @$pb.TagNumber(137) - $core.bool hasPyroscopeAppName() => $_has(27); - @$pb.TagNumber(137) - void clearPyroscopeAppName() => $_clearField(137); + @$pb.TagNumber(171) + $core.String get pyroscopeAppName => $_getSZ(53); + @$pb.TagNumber(171) + set pyroscopeAppName($core.String value) => $_setString(53, value); + @$pb.TagNumber(171) + $core.bool hasPyroscopeAppName() => $_has(53); + @$pb.TagNumber(171) + void clearPyroscopeAppName() => $_clearField(171); /// CPU profile sampling rate in Hz. Default 100. The Pyroscope /// agent uses this to call runtime.SetCPUProfileRate at startup. - @$pb.TagNumber(138) - $core.int get pyroscopeSampleHz => $_getIZ(28); - @$pb.TagNumber(138) - set pyroscopeSampleHz($core.int value) => $_setUnsignedInt32(28, value); - @$pb.TagNumber(138) - $core.bool hasPyroscopeSampleHz() => $_has(28); - @$pb.TagNumber(138) - void clearPyroscopeSampleHz() => $_clearField(138); + @$pb.TagNumber(172) + $core.int get pyroscopeSampleHz => $_getIZ(54); + @$pb.TagNumber(172) + set pyroscopeSampleHz($core.int value) => $_setUnsignedInt32(54, value); + @$pb.TagNumber(172) + $core.bool hasPyroscopeSampleHz() => $_has(54); + @$pb.TagNumber(172) + void clearPyroscopeSampleHz() => $_clearField(172); /// Profile upload interval (seconds between batched profile /// pushes). Default 15 s. - @$pb.TagNumber(139) - $core.int get pyroscopeUploadIntervalSec => $_getIZ(29); - @$pb.TagNumber(139) + @$pb.TagNumber(173) + $core.int get pyroscopeUploadIntervalSec => $_getIZ(55); + @$pb.TagNumber(173) set pyroscopeUploadIntervalSec($core.int value) => - $_setUnsignedInt32(29, value); - @$pb.TagNumber(139) - $core.bool hasPyroscopeUploadIntervalSec() => $_has(29); - @$pb.TagNumber(139) - void clearPyroscopeUploadIntervalSec() => $_clearField(139); - - /// Kafka or NSQ topic - @$pb.TagNumber(140) - $core.String get topic => $_getSZ(30); - @$pb.TagNumber(140) - set topic($core.String value) => $_setString(30, value); - @$pb.TagNumber(140) - $core.bool hasTopic() => $_has(30); - @$pb.TagNumber(140) - void clearTopic() => $_clearField(140); - - /// XtcpProtoFile - @$pb.TagNumber(143) - $core.String get xtcpProtoFile => $_getSZ(31); - @$pb.TagNumber(143) - set xtcpProtoFile($core.String value) => $_setString(31, value); - @$pb.TagNumber(143) - $core.bool hasXtcpProtoFile() => $_has(31); - @$pb.TagNumber(143) - void clearXtcpProtoFile() => $_clearField(143); - - /// Kafka schema registry url - @$pb.TagNumber(145) - $core.String get kafkaSchemaUrl => $_getSZ(32); - @$pb.TagNumber(145) - set kafkaSchemaUrl($core.String value) => $_setString(32, value); - @$pb.TagNumber(145) - $core.bool hasKafkaSchemaUrl() => $_has(32); - @$pb.TagNumber(145) - void clearKafkaSchemaUrl() => $_clearField(145); - - /// Kafka Produce context timeout. Use 0 for no context timeout - /// Recommend a small timeout, like 1-2 seconds - /// kgo seems to have a bug, because the timeout is always expired - @$pb.TagNumber(150) - $1.Duration get kafkaProduceTimeout => $_getN(33); - @$pb.TagNumber(150) - set kafkaProduceTimeout($1.Duration value) => $_setField(150, value); - @$pb.TagNumber(150) - $core.bool hasKafkaProduceTimeout() => $_has(33); - @$pb.TagNumber(150) - void clearKafkaProduceTimeout() => $_clearField(150); - @$pb.TagNumber(150) - $1.Duration ensureKafkaProduceTimeout() => $_ensure(33); - - /// DebugLevel - @$pb.TagNumber(160) - $core.int get debugLevel => $_getIZ(34); - @$pb.TagNumber(160) - set debugLevel($core.int value) => $_setUnsignedInt32(34, value); - @$pb.TagNumber(160) - $core.bool hasDebugLevel() => $_has(34); - @$pb.TagNumber(160) - void clearDebugLevel() => $_clearField(160); - - /// Label applied to the protobuf - @$pb.TagNumber(170) - $core.String get label => $_getSZ(35); - @$pb.TagNumber(170) - set label($core.String value) => $_setString(35, value); - @$pb.TagNumber(170) - $core.bool hasLabel() => $_has(35); - @$pb.TagNumber(170) - void clearLabel() => $_clearField(170); - - /// Tag applied to the protobuf - @$pb.TagNumber(180) - $core.String get tag => $_getSZ(36); - @$pb.TagNumber(180) - set tag($core.String value) => $_setString(36, value); - @$pb.TagNumber(180) - $core.bool hasTag() => $_has(36); - @$pb.TagNumber(180) - void clearTag() => $_clearField(180); - - /// Deployment grouping / facility this daemon runs in (data center, PoP, - /// region, site, …). Generic; stamped on every record's `location` field. - /// Set via -location flag or LOCATION env. - @$pb.TagNumber(181) - $core.String get location => $_getSZ(37); - @$pb.TagNumber(181) - set location($core.String value) => $_setString(37, value); - @$pb.TagNumber(181) - $core.bool hasLocation() => $_has(37); - @$pb.TagNumber(181) - void clearLocation() => $_clearField(181); - - /// Hostname override. When empty the daemon uses os.Hostname(); set this to - /// stamp an explicit hostname on records — required in containers, where - /// os.Hostname() returns the container id, not the host. Set via -hostname - /// flag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the - /// container id). - @$pb.TagNumber(182) - $core.String get hostname => $_getSZ(38); - @$pb.TagNumber(182) - set hostname($core.String value) => $_setString(38, value); - @$pb.TagNumber(182) - $core.bool hasHostname() => $_has(38); - @$pb.TagNumber(182) - void clearHostname() => $_clearField(182); - - /// Resolve each socket's owning container id from its cgroup (sets the - /// record's container_id / container_runtime). Set via -resolveContainerId - /// flag or CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it - /// and run --cgroupns=host in a container). - @$pb.TagNumber(183) - $core.bool get resolveContainerId => $_getBF(39); - @$pb.TagNumber(183) - set resolveContainerId($core.bool value) => $_setBool(39, value); - @$pb.TagNumber(183) - $core.bool hasResolveContainerId() => $_has(39); - @$pb.TagNumber(183) - void clearResolveContainerId() => $_clearField(183); - - /// Outgoing IPv4 TTL for xtcp2's own TCP listeners (Prometheus + gRPC). - /// 0 = kernel default. A low value (e.g. 3) keeps replies from travelling - /// far if the host is unexpectedly internet-exposed — the per-listener - /// analogue of the host nftables TTL clamp. Set via -ipv4Ttl / IPV4_TTL. - /// (cf. prometheus/exporter-toolkit#396.) - @$pb.TagNumber(184) - $core.int get ipv4Ttl => $_getIZ(40); - @$pb.TagNumber(184) - set ipv4Ttl($core.int value) => $_setUnsignedInt32(40, value); - @$pb.TagNumber(184) - $core.bool hasIpv4Ttl() => $_has(40); - @$pb.TagNumber(184) - void clearIpv4Ttl() => $_clearField(184); - - /// Outgoing IPv6 unicast hop limit for xtcp2's own TCP listeners. 0 = kernel - /// default. Same intent as ipv4_ttl. Set via -ipv6HopLimit / IPV6_HOP_LIMIT. - @$pb.TagNumber(185) - $core.int get ipv6HopLimit => $_getIZ(41); - @$pb.TagNumber(185) - set ipv6HopLimit($core.int value) => $_setUnsignedInt32(41, value); - @$pb.TagNumber(185) - $core.bool hasIpv6HopLimit() => $_has(41); - @$pb.TagNumber(185) - void clearIpv6HopLimit() => $_clearField(185); - - /// Daemon build provenance stamped on every record's `daemon_version` field - /// (git commit / date / version). Populated by the daemon from -ldflags build - /// vars, not a user flag; informational only (debugging which binary produced a - /// row). See XtcpFlatRecord.daemon_version. - @$pb.TagNumber(186) - $core.String get daemonVersion => $_getSZ(42); - @$pb.TagNumber(186) - set daemonVersion($core.String value) => $_setString(42, value); - @$pb.TagNumber(186) - $core.bool hasDaemonVersion() => $_has(42); - @$pb.TagNumber(186) - void clearDaemonVersion() => $_clearField(186); - - /// GRPC listening port - @$pb.TagNumber(190) - $core.int get grpcPort => $_getIZ(43); - @$pb.TagNumber(190) - set grpcPort($core.int value) => $_setUnsignedInt32(43, value); - @$pb.TagNumber(190) - $core.bool hasGrpcPort() => $_has(43); - @$pb.TagNumber(190) - void clearGrpcPort() => $_clearField(190); - + $_setUnsignedInt32(55, value); + @$pb.TagNumber(173) + $core.bool hasPyroscopeUploadIntervalSec() => $_has(55); + @$pb.TagNumber(173) + void clearPyroscopeUploadIntervalSec() => $_clearField(173); + + /// -- container (200-209) + /// Resolve each socket's owning container id from its cgroup v2 id + /// (inet_diag_cgroup_id, record field 2003) — sets the record's + /// container_id / container_runtime. Set via -resolveContainerId flag or + /// CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it and run + /// --cgroupns=host in a container). @$pb.TagNumber(200) - EnabledDeserializers get enabledDeserializers => $_getN(44); + $core.bool get resolveContainerId => $_getBF(56); @$pb.TagNumber(200) - set enabledDeserializers(EnabledDeserializers value) => - $_setField(200, value); + set resolveContainerId($core.bool value) => $_setBool(56, value); @$pb.TagNumber(200) - $core.bool hasEnabledDeserializers() => $_has(44); + $core.bool hasResolveContainerId() => $_has(56); @$pb.TagNumber(200) - void clearEnabledDeserializers() => $_clearField(200); - @$pb.TagNumber(200) - EnabledDeserializers ensureEnabledDeserializers() => $_ensure(44); - - /// When true, route netlink reads and raw-socket destination writes - /// through an io_uring ring per Netlinker. Requires Linux 6.1+. - /// Library-backed destinations (kafka, nsq, nats, valkey) ignore this - /// flag — they continue to use their own client sockets unchanged. - @$pb.TagNumber(210) - $core.bool get ioUring => $_getBF(45); - @$pb.TagNumber(210) - set ioUring($core.bool value) => $_setBool(45, value); - @$pb.TagNumber(210) - $core.bool hasIoUring() => $_has(45); - @$pb.TagNumber(210) - void clearIoUring() => $_clearField(210); - - /// Number of recvmsg SQEs kept in flight per Netlinker ring. Higher - /// values reduce io_uring_enter syscalls per dump cycle on hosts with - /// many sockets, at the cost of more pinned buffers from packet pool. - /// Ignored unless io_uring=true. Default 64. - @$pb.TagNumber(211) - $core.int get ioUringRecvBatchSize => $_getIZ(46); - @$pb.TagNumber(211) - set ioUringRecvBatchSize($core.int value) => $_setUnsignedInt32(46, value); - @$pb.TagNumber(211) - $core.bool hasIoUringRecvBatchSize() => $_has(46); - @$pb.TagNumber(211) - void clearIoUringRecvBatchSize() => $_clearField(211); - - /// Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise - /// userland loop overhead but increase scheduling latency for the - /// netlinker goroutine. Ignored unless io_uring=true. Default 128. - @$pb.TagNumber(212) - $core.int get ioUringCqeBatchSize => $_getIZ(47); - @$pb.TagNumber(212) - set ioUringCqeBatchSize($core.int value) => $_setUnsignedInt32(47, value); - @$pb.TagNumber(212) - $core.bool hasIoUringCqeBatchSize() => $_has(47); - @$pb.TagNumber(212) - void clearIoUringCqeBatchSize() => $_clearField(212); - - /// Comma-separated subset of XtcpFlatRecord json field names selecting - /// which columns the csv/tsv marshallers emit (e.g. - /// "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). - /// Empty = all fields. Ignored by non-tabular marshallers. - @$pb.TagNumber(220) - $core.String get csvColumns => $_getSZ(48); - @$pb.TagNumber(220) - set csvColumns($core.String value) => $_setString(48, value); - @$pb.TagNumber(220) - $core.bool hasCsvColumns() => $_has(48); - @$pb.TagNumber(220) - void clearCsvColumns() => $_clearField(220); - - /// Maximum poll-schedule jitter as a percent of poll_frequency, applied to - /// both the startup delay before the first poll and each subsequent tick. - /// 0 disables (immediate first poll, fixed interval). Default 20. - @$pb.TagNumber(221) - $core.int get pollJitterPct => $_getIZ(49); - @$pb.TagNumber(221) - set pollJitterPct($core.int value) => $_setUnsignedInt32(49, value); - @$pb.TagNumber(221) - $core.bool hasPollJitterPct() => $_has(49); - @$pb.TagNumber(221) - void clearPollJitterPct() => $_clearField(221); - - /// s3parquet staleness ceiling: force-flush the in-memory Parquet object - /// after this long even if it hasn't reached the byte cap, bounding upload - /// latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). - @$pb.TagNumber(222) - $1.Duration get s3FlushInterval => $_getN(50); - @$pb.TagNumber(222) - set s3FlushInterval($1.Duration value) => $_setField(222, value); - @$pb.TagNumber(222) - $core.bool hasS3FlushInterval() => $_has(50); - @$pb.TagNumber(222) - void clearS3FlushInterval() => $_clearField(222); - @$pb.TagNumber(222) - $1.Duration ensureS3FlushInterval() => $_ensure(50); - - /// Maximum jitter as a percent of s3_flush_interval, applied to the first - /// timed flush and each interval so the fleet doesn't ceiling-flush in - /// lockstep. 0 disables. Default 20. - @$pb.TagNumber(223) - $core.int get s3FlushJitterPct => $_getIZ(51); - @$pb.TagNumber(223) - set s3FlushJitterPct($core.int value) => $_setUnsignedInt32(51, value); - @$pb.TagNumber(223) - $core.bool hasS3FlushJitterPct() => $_has(51); - @$pb.TagNumber(223) - void clearS3FlushJitterPct() => $_clearField(223); - - /// Per-object downward jitter as a percent of the s3parquet byte cap: each - /// object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the - /// size-cap upload path even under uniform load. Downward-only, so an - /// object never exceeds the in-memory byte bound. 0 disables. Default 20. - @$pb.TagNumber(224) - $core.int get s3FlushThresholdJitterPct => $_getIZ(52); - @$pb.TagNumber(224) - set s3FlushThresholdJitterPct($core.int value) => - $_setUnsignedInt32(52, value); - @$pb.TagNumber(224) - $core.bool hasS3FlushThresholdJitterPct() => $_has(52); - @$pb.TagNumber(224) - void clearS3FlushThresholdJitterPct() => $_clearField(224); - - /// Maximum S3 upload attempts (original + retries) before dropping the - /// object. Retries use full-jitter exponential backoff. Default 10. - @$pb.TagNumber(225) - $core.int get s3UploadMaxAttempts => $_getIZ(53); - @$pb.TagNumber(225) - set s3UploadMaxAttempts($core.int value) => $_setUnsignedInt32(53, value); - @$pb.TagNumber(225) - $core.bool hasS3UploadMaxAttempts() => $_has(53); - @$pb.TagNumber(225) - void clearS3UploadMaxAttempts() => $_clearField(225); - - /// Cap on a single upload retry's backoff window (full jitter draws in - /// [0, window], window grows exponentially up to this cap). 0 = derive as - /// clamp(poll_frequency/10, 1s, 1h). - @$pb.TagNumber(226) - $1.Duration get s3UploadBackoffCap => $_getN(54); - @$pb.TagNumber(226) - set s3UploadBackoffCap($1.Duration value) => $_setField(226, value); - @$pb.TagNumber(226) - $core.bool hasS3UploadBackoffCap() => $_has(54); - @$pb.TagNumber(226) - void clearS3UploadBackoffCap() => $_clearField(226); - @$pb.TagNumber(226) - $1.Duration ensureS3UploadBackoffCap() => $_ensure(54); - - /// Period of the background namespace-reconcile ticker (Method B /proc scan - /// that converges the tracked namespace set). With reconcile_before_poll the - /// Poller reconciles every cycle and is the real discovery mechanism, so this - /// background pass is an occasional safety-net expected to find nothing - /// (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) - /// so operators can confirm from the counters that it is redundant. It still - /// matters when the poller is idle or disabled. 0 disables the background - /// ticker entirely (the startup reconcile still runs once). - @$pb.TagNumber(227) - $1.Duration get reconcileFrequency => $_getN(55); - @$pb.TagNumber(227) - set reconcileFrequency($1.Duration value) => $_setField(227, value); - @$pb.TagNumber(227) - $core.bool hasReconcileFrequency() => $_has(55); - @$pb.TagNumber(227) - void clearReconcileFrequency() => $_clearField(227); - @$pb.TagNumber(227) - $1.Duration ensureReconcileFrequency() => $_ensure(55); - - /// Run a namespace reconcile immediately before each poll cycle, so a - /// namespace that appeared since the last cycle is entered and gets a socket - /// within ~1 poll interval instead of waiting for the background ticker. Ties - /// discovery cadence to poll cadence; the /proc scan is zero-allocation and - /// mutex-serialized with the background reconciler. Default true. - @$pb.TagNumber(228) - $core.bool get reconcileBeforePoll => $_getBF(56); - @$pb.TagNumber(228) - set reconcileBeforePoll($core.bool value) => $_setBool(56, value); - @$pb.TagNumber(228) - $core.bool hasReconcileBeforePoll() => $_has(56); - @$pb.TagNumber(228) - void clearReconcileBeforePoll() => $_clearField(228); + void clearResolveContainerId() => $_clearField(200); /// Enrich container/netns labels (container_id/name/image/runtime, netns name) /// by joining the socket's owning netns inode against the Docker Engine API /// index over docker_socket_path. Default false. - @$pb.TagNumber(230) + @$pb.TagNumber(201) $core.bool get enrichContainerEnable => $_getBF(57); - @$pb.TagNumber(230) + @$pb.TagNumber(201) set enrichContainerEnable($core.bool value) => $_setBool(57, value); - @$pb.TagNumber(230) + @$pb.TagNumber(201) $core.bool hasEnrichContainerEnable() => $_has(57); - @$pb.TagNumber(230) - void clearEnrichContainerEnable() => $_clearField(230); + @$pb.TagNumber(201) + void clearEnrichContainerEnable() => $_clearField(201); /// Docker Engine API unix socket. Default "/run/docker.sock". - @$pb.TagNumber(231) + @$pb.TagNumber(202) $core.String get dockerSocketPath => $_getSZ(58); - @$pb.TagNumber(231) + @$pb.TagNumber(202) set dockerSocketPath($core.String value) => $_setString(58, value); - @$pb.TagNumber(231) + @$pb.TagNumber(202) $core.bool hasDockerSocketPath() => $_has(58); - @$pb.TagNumber(231) - void clearDockerSocketPath() => $_clearField(231); + @$pb.TagNumber(202) + void clearDockerSocketPath() => $_clearField(202); + /// -- lldp (210-219) /// Enrich per-uplink LLDP neighbor labels by reading the lldpd control socket /// (lldpd_socket_path) once at startup. Default false. - @$pb.TagNumber(232) + @$pb.TagNumber(210) $core.bool get enrichLldpEnable => $_getBF(59); - @$pb.TagNumber(232) + @$pb.TagNumber(210) set enrichLldpEnable($core.bool value) => $_setBool(59, value); - @$pb.TagNumber(232) + @$pb.TagNumber(210) $core.bool hasEnrichLldpEnable() => $_has(59); - @$pb.TagNumber(232) - void clearEnrichLldpEnable() => $_clearField(232); + @$pb.TagNumber(210) + void clearEnrichLldpEnable() => $_clearField(210); /// lldpd control socket. Default "/run/lldpd.socket". - @$pb.TagNumber(233) + @$pb.TagNumber(211) $core.String get lldpdSocketPath => $_getSZ(60); - @$pb.TagNumber(233) + @$pb.TagNumber(211) set lldpdSocketPath($core.String value) => $_setString(60, value); - @$pb.TagNumber(233) + @$pb.TagNumber(211) $core.bool hasLldpdSocketPath() => $_has(60); - @$pb.TagNumber(233) - void clearLldpdSocketPath() => $_clearField(233); + @$pb.TagNumber(211) + void clearLldpdSocketPath() => $_clearField(211); /// Optional lldpd version hint ("1.0.13"/"1.0.18") selecting the struct-layout /// descriptor for the wire parser. Empty = auto-detect. Default "". - @$pb.TagNumber(234) + @$pb.TagNumber(212) $core.String get lldpdVersionHint => $_getSZ(61); - @$pb.TagNumber(234) + @$pb.TagNumber(212) set lldpdVersionHint($core.String value) => $_setString(61, value); - @$pb.TagNumber(234) + @$pb.TagNumber(212) $core.bool hasLldpdVersionHint() => $_has(61); - @$pb.TagNumber(234) - void clearLldpdVersionHint() => $_clearField(234); + @$pb.TagNumber(212) + void clearLldpdVersionHint() => $_clearField(212); + /// -- nic (220-229) /// Enrich per-uplink NIC labels (driver/model/pci/speed/firmware) from sysfs + /// the ethtool ioctl once at startup. Default false. - @$pb.TagNumber(235) + @$pb.TagNumber(220) $core.bool get enrichNicEnable => $_getBF(62); - @$pb.TagNumber(235) + @$pb.TagNumber(220) set enrichNicEnable($core.bool value) => $_setBool(62, value); - @$pb.TagNumber(235) + @$pb.TagNumber(220) $core.bool hasEnrichNicEnable() => $_has(62); - @$pb.TagNumber(235) - void clearEnrichNicEnable() => $_clearField(235); + @$pb.TagNumber(220) + void clearEnrichNicEnable() => $_clearField(220); /// Number of host uplink slots to populate (dual-homed hosts = 2). Default 2. - @$pb.TagNumber(236) + @$pb.TagNumber(221) $core.int get uplinkCount => $_getIZ(63); - @$pb.TagNumber(236) + @$pb.TagNumber(221) set uplinkCount($core.int value) => $_setUnsignedInt32(63, value); - @$pb.TagNumber(236) + @$pb.TagNumber(221) $core.bool hasUplinkCount() => $_has(63); - @$pb.TagNumber(236) - void clearUplinkCount() => $_clearField(236); + @$pb.TagNumber(221) + void clearUplinkCount() => $_clearField(221); /// Explicit uplink interface names, slot order. Empty = auto-detect from the /// default IPv4/IPv6 routes. - @$pb.TagNumber(237) + @$pb.TagNumber(222) $pb.PbList<$core.String> get uplinkInterfaces => $_getList(64); - /// Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for + /// -- nsid (230-239) + /// Populate nsid (record field 32) best-effort via RTM_GETNSID. Usually 0 for /// Docker/containerd namespaces. Default false. - @$pb.TagNumber(238) + @$pb.TagNumber(230) $core.bool get populateNsid => $_getBF(65); - @$pb.TagNumber(238) + @$pb.TagNumber(230) set populateNsid($core.bool value) => $_setBool(65, value); - @$pb.TagNumber(238) + @$pb.TagNumber(230) $core.bool hasPopulateNsid() => $_has(65); - @$pb.TagNumber(238) - void clearPopulateNsid() => $_clearField(238); + @$pb.TagNumber(230) + void clearPopulateNsid() => $_clearField(230); - /// Enrich the destination IP's ASN (field 1011) and network owner (field - /// 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + /// -- asn (240-244) + /// Enrich the destination IP's ASN (record field 320) and network owner + /// (322) by longest-prefix-matching it against the ipfeed-collector Parquet /// artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when /// enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, /// and leaves both columns empty. Default false. - @$pb.TagNumber(239) + @$pb.TagNumber(240) $core.bool get enrichAsnEnable => $_getBF(66); - @$pb.TagNumber(239) + @$pb.TagNumber(240) set enrichAsnEnable($core.bool value) => $_setBool(66, value); - @$pb.TagNumber(239) + @$pb.TagNumber(240) $core.bool hasEnrichAsnEnable() => $_has(66); - @$pb.TagNumber(239) - void clearEnrichAsnEnable() => $_clearField(239); + @$pb.TagNumber(240) + void clearEnrichAsnEnable() => $_clearField(240); /// Path to the ipfeed-collector Parquet artifact (prefix -> {asn, /// network_owner}). Default "". - @$pb.TagNumber(240) + @$pb.TagNumber(241) $core.String get asnDbPath => $_getSZ(67); - @$pb.TagNumber(240) + @$pb.TagNumber(241) set asnDbPath($core.String value) => $_setString(67, value); - @$pb.TagNumber(240) + @$pb.TagNumber(241) $core.bool hasAsnDbPath() => $_has(67); - @$pb.TagNumber(240) - void clearAsnDbPath() => $_clearField(240); + @$pb.TagNumber(241) + void clearAsnDbPath() => $_clearField(241); /// How often to reload asn_db_path in the background so a refreshed artifact /// is picked up without a restart. 0 = load once at startup, never reload. - @$pb.TagNumber(241) + @$pb.TagNumber(242) $1.Duration get asnRefreshInterval => $_getN(68); - @$pb.TagNumber(241) - set asnRefreshInterval($1.Duration value) => $_setField(241, value); - @$pb.TagNumber(241) + @$pb.TagNumber(242) + set asnRefreshInterval($1.Duration value) => $_setField(242, value); + @$pb.TagNumber(242) $core.bool hasAsnRefreshInterval() => $_has(68); - @$pb.TagNumber(241) - void clearAsnRefreshInterval() => $_clearField(241); - @$pb.TagNumber(241) + @$pb.TagNumber(242) + void clearAsnRefreshInterval() => $_clearField(242); + @$pb.TagNumber(242) $1.Duration ensureAsnRefreshInterval() => $_ensure(68); - /// Classify the destination IP's locality (field 1019) — self / - /// connected-subnet / remote — from each monitored network namespace's local - /// addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs - /// BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: - /// a per-namespace discovery failure just leaves that namespace's sockets - /// unclassified. Default false. - @$pb.TagNumber(242) + /// -- locality (245-249) + /// Classify the destination IP's locality (record field 310) — self / + /// local-subnet / remote — from each monitored network namespace's local + /// addresses + routing table, discovered via rtnetlink (pkg/localnet). Also + /// yields the egress interface (311/312) and the bound-interface name (300). + /// Runs BEFORE the ASN lookup, so self/local-subnet destinations skip it. + /// Non-fatal: a per-namespace discovery failure just leaves that namespace's + /// sockets unclassified (and is retried with backoff). Default false. + @$pb.TagNumber(245) $core.bool get enrichLocalityEnable => $_getBF(69); - @$pb.TagNumber(242) + @$pb.TagNumber(245) set enrichLocalityEnable($core.bool value) => $_setBool(69, value); - @$pb.TagNumber(242) + @$pb.TagNumber(245) $core.bool hasEnrichLocalityEnable() => $_has(69); - @$pb.TagNumber(242) - void clearEnrichLocalityEnable() => $_clearField(242); + @$pb.TagNumber(245) + void clearEnrichLocalityEnable() => $_clearField(245); /// How often to re-discover local addresses/routes per namespace so runtime /// changes (interfaces up/down, routes added) are picked up. Newly-appeared /// namespaces are always snapshotted on the next reconcile regardless. 0 = - /// discover once per namespace, never refresh. - @$pb.TagNumber(243) + /// discover once per namespace, never refresh. Daemon default 60s. + @$pb.TagNumber(246) $1.Duration get localityRefreshInterval => $_getN(70); - @$pb.TagNumber(243) - set localityRefreshInterval($1.Duration value) => $_setField(243, value); - @$pb.TagNumber(243) + @$pb.TagNumber(246) + set localityRefreshInterval($1.Duration value) => $_setField(246, value); + @$pb.TagNumber(246) $core.bool hasLocalityRefreshInterval() => $_has(70); - @$pb.TagNumber(243) - void clearLocalityRefreshInterval() => $_clearField(243); - @$pb.TagNumber(243) + @$pb.TagNumber(246) + void clearLocalityRefreshInterval() => $_clearField(246); + @$pb.TagNumber(246) $1.Duration ensureLocalityRefreshInterval() => $_ensure(70); } diff --git a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart index 16b7028..11b7552 100644 --- a/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart +++ b/gen/dart/xtcp_config/v1/xtcp_config.pbjson.dart @@ -327,7 +327,7 @@ const XtcpConfig$json = { }, { '1': 'poll_frequency', - '3': 20, + '3': 11, '4': 1, '5': 11, '6': '.google.protobuf.Duration', @@ -336,157 +336,133 @@ const XtcpConfig$json = { }, { '1': 'poll_timeout', - '3': 30, + '3': 12, '4': 1, '5': 11, '6': '.google.protobuf.Duration', '8': {}, '10': 'pollTimeout' }, - {'1': 'max_loops', '3': 40, '4': 1, '5': 4, '8': {}, '10': 'maxLoops'}, - {'1': 'netlinkers', '3': 50, '4': 1, '5': 13, '8': {}, '10': 'netlinkers'}, + { + '1': 'poll_jitter_pct', + '3': 13, + '4': 1, + '5': 13, + '8': {}, + '10': 'pollJitterPct' + }, + {'1': 'max_loops', '3': 14, '4': 1, '5': 4, '8': {}, '10': 'maxLoops'}, + {'1': 'netlinkers', '3': 15, '4': 1, '5': 13, '8': {}, '10': 'netlinkers'}, { '1': 'netlinkers_done_chan_size', - '3': 51, + '3': 16, '4': 1, '5': 13, '8': {}, '10': 'netlinkersDoneChanSize' }, - {'1': 'nlmsg_seq', '3': 60, '4': 1, '5': 13, '8': {}, '10': 'nlmsgSeq'}, - {'1': 'packet_size', '3': 70, '4': 1, '5': 4, '8': {}, '10': 'packetSize'}, + {'1': 'nlmsg_seq', '3': 17, '4': 1, '5': 13, '8': {}, '10': 'nlmsgSeq'}, + {'1': 'packet_size', '3': 18, '4': 1, '5': 4, '8': {}, '10': 'packetSize'}, { '1': 'packet_size_mply', - '3': 80, + '3': 19, '4': 1, '5': 13, '8': {}, '10': 'packetSizeMply' }, - {'1': 'write_files', '3': 90, '4': 1, '5': 13, '8': {}, '10': 'writeFiles'}, + {'1': 'modulus', '3': 20, '4': 1, '5': 4, '8': {}, '10': 'modulus'}, { - '1': 'capture_path', - '3': 100, + '1': 'enabled_deserializers', + '3': 21, '4': 1, - '5': 9, + '5': 11, + '6': '.xtcp_config.v1.EnabledDeserializers', '8': {}, - '10': 'capturePath' + '10': 'enabledDeserializers' }, - {'1': 'modulus', '3': 110, '4': 1, '5': 4, '8': {}, '10': 'modulus'}, - {'1': 'marshal_to', '3': 120, '4': 1, '5': 9, '8': {}, '10': 'marshalTo'}, + {'1': 'io_uring', '3': 22, '4': 1, '5': 8, '8': {}, '10': 'ioUring'}, { - '1': 'envelope_flush_threshold_bytes', - '3': 122, + '1': 'io_uring_recv_batch_size', + '3': 23, '4': 1, '5': 13, '8': {}, - '10': 'envelopeFlushThresholdBytes' + '10': 'ioUringRecvBatchSize' }, { - '1': 'envelope_flush_threshold_rows', - '3': 123, + '1': 'io_uring_cqe_batch_size', + '3': 24, '4': 1, '5': 13, '8': {}, - '10': 'envelopeFlushThresholdRows' + '10': 'ioUringCqeBatchSize' }, { - '1': 'kafka_compression', - '3': 124, + '1': 'reconcile_frequency', + '3': 40, '4': 1, - '5': 9, + '5': 11, + '6': '.google.protobuf.Duration', '8': {}, - '10': 'kafkaCompression' + '10': 'reconcileFrequency' }, - {'1': 's3_endpoint', '3': 125, '4': 1, '5': 9, '8': {}, '10': 's3Endpoint'}, - {'1': 's3_bucket', '3': 126, '4': 1, '5': 9, '8': {}, '10': 's3Bucket'}, - {'1': 's3_prefix', '3': 127, '4': 1, '5': 9, '8': {}, '10': 's3Prefix'}, { - '1': 's3_access_key', - '3': 128, + '1': 'reconcile_before_poll', + '3': 41, '4': 1, - '5': 9, - '8': {}, - '10': 's3AccessKey' + '5': 8, + '10': 'reconcileBeforePoll' }, + {'1': 'write_files', '3': 50, '4': 1, '5': 13, '8': {}, '10': 'writeFiles'}, { - '1': 's3_secret_key', - '3': 129, + '1': 'capture_path', + '3': 51, '4': 1, '5': 9, '8': {}, - '10': 's3SecretKey' + '10': 'capturePath' }, { - '1': 's3_parquet_flush_threshold_bytes', - '3': 132, + '1': 'dest_write_files', + '3': 52, '4': 1, '5': 13, '8': {}, - '10': 's3ParquetFlushThresholdBytes' - }, - {'1': 's3_region', '3': 133, '4': 1, '5': 9, '8': {}, '10': 's3Region'}, - { - '1': 's3_skip_bucket_probe', - '3': 134, - '4': 1, - '5': 8, - '8': {}, - '10': 's3SkipBucketProbe' - }, - { - '1': 'pyroscope_url', - '3': 136, - '4': 1, - '5': 9, - '8': {}, - '10': 'pyroscopeUrl' + '10': 'destWriteFiles' }, + {'1': 'debug_level', '3': 53, '4': 1, '5': 13, '8': {}, '10': 'debugLevel'}, + {'1': 'dest', '3': 60, '4': 1, '5': 9, '8': {}, '10': 'dest'}, + {'1': 'marshal_to', '3': 61, '4': 1, '5': 9, '8': {}, '10': 'marshalTo'}, + {'1': 'csv_columns', '3': 62, '4': 1, '5': 9, '8': {}, '10': 'csvColumns'}, { - '1': 'pyroscope_app_name', - '3': 137, + '1': 'xtcp_proto_file', + '3': 63, '4': 1, '5': 9, '8': {}, - '10': 'pyroscopeAppName' - }, - { - '1': 'pyroscope_sample_hz', - '3': 138, - '4': 1, - '5': 13, - '8': {}, - '10': 'pyroscopeSampleHz' + '10': 'xtcpProtoFile' }, { - '1': 'pyroscope_upload_interval_sec', - '3': 139, + '1': 'envelope_flush_threshold_bytes', + '3': 64, '4': 1, '5': 13, '8': {}, - '10': 'pyroscopeUploadIntervalSec' + '10': 'envelopeFlushThresholdBytes' }, - {'1': 'dest', '3': 130, '4': 1, '5': 9, '8': {}, '10': 'dest'}, { - '1': 'dest_write_files', - '3': 135, + '1': 'envelope_flush_threshold_rows', + '3': 65, '4': 1, '5': 13, '8': {}, - '10': 'destWriteFiles' - }, - {'1': 'topic', '3': 140, '4': 1, '5': 9, '8': {}, '10': 'topic'}, - { - '1': 'xtcp_proto_file', - '3': 143, - '4': 1, - '5': 9, - '8': {}, - '10': 'xtcpProtoFile' + '10': 'envelopeFlushThresholdRows' }, + {'1': 'topic', '3': 80, '4': 1, '5': 9, '8': {}, '10': 'topic'}, { '1': 'kafka_schema_url', - '3': 145, + '3': 81, '4': 1, '5': 9, '8': {}, @@ -494,7 +470,7 @@ const XtcpConfig$json = { }, { '1': 'kafka_produce_timeout', - '3': 150, + '3': 82, '4': 1, '5': 11, '6': '.google.protobuf.Duration', @@ -502,146 +478,163 @@ const XtcpConfig$json = { '10': 'kafkaProduceTimeout' }, { - '1': 'debug_level', - '3': 160, + '1': 'kafka_compression', + '3': 83, '4': 1, - '5': 13, + '5': 9, '8': {}, - '10': 'debugLevel' + '10': 'kafkaCompression' }, - {'1': 'label', '3': 170, '4': 1, '5': 9, '8': {}, '10': 'label'}, - {'1': 'tag', '3': 180, '4': 1, '5': 9, '8': {}, '10': 'tag'}, - {'1': 'location', '3': 181, '4': 1, '5': 9, '8': {}, '10': 'location'}, - {'1': 'hostname', '3': 182, '4': 1, '5': 9, '8': {}, '10': 'hostname'}, + {'1': 's3_endpoint', '3': 100, '4': 1, '5': 9, '8': {}, '10': 's3Endpoint'}, + {'1': 's3_region', '3': 101, '4': 1, '5': 9, '8': {}, '10': 's3Region'}, + {'1': 's3_bucket', '3': 102, '4': 1, '5': 9, '8': {}, '10': 's3Bucket'}, + {'1': 's3_prefix', '3': 103, '4': 1, '5': 9, '8': {}, '10': 's3Prefix'}, { - '1': 'daemon_version', - '3': 186, + '1': 's3_access_key', + '3': 104, '4': 1, '5': 9, '8': {}, - '10': 'daemonVersion' + '10': 's3AccessKey' }, { - '1': 'resolve_container_id', - '3': 183, + '1': 's3_secret_key', + '3': 105, + '4': 1, + '5': 9, + '8': {}, + '10': 's3SecretKey' + }, + { + '1': 's3_skip_bucket_probe', + '3': 106, '4': 1, '5': 8, '8': {}, - '10': 'resolveContainerId' + '10': 's3SkipBucketProbe' }, - {'1': 'ipv4_ttl', '3': 184, '4': 1, '5': 13, '8': {}, '10': 'ipv4Ttl'}, { - '1': 'ipv6_hop_limit', - '3': 185, + '1': 's3_parquet_flush_threshold_bytes', + '3': 110, '4': 1, '5': 13, '8': {}, - '10': 'ipv6HopLimit' + '10': 's3ParquetFlushThresholdBytes' }, - {'1': 'grpc_port', '3': 190, '4': 1, '5': 13, '8': {}, '10': 'grpcPort'}, { - '1': 'enabled_deserializers', - '3': 200, + '1': 's3_flush_interval', + '3': 111, '4': 1, '5': 11, - '6': '.xtcp_config.v1.EnabledDeserializers', + '6': '.google.protobuf.Duration', '8': {}, - '10': 'enabledDeserializers' + '10': 's3FlushInterval' }, - {'1': 'io_uring', '3': 210, '4': 1, '5': 8, '8': {}, '10': 'ioUring'}, { - '1': 'io_uring_recv_batch_size', - '3': 211, + '1': 's3_flush_jitter_pct', + '3': 112, '4': 1, '5': 13, '8': {}, - '10': 'ioUringRecvBatchSize' + '10': 's3FlushJitterPct' }, { - '1': 'io_uring_cqe_batch_size', - '3': 212, + '1': 's3_flush_threshold_jitter_pct', + '3': 113, '4': 1, '5': 13, '8': {}, - '10': 'ioUringCqeBatchSize' + '10': 's3FlushThresholdJitterPct' }, - {'1': 'csv_columns', '3': 220, '4': 1, '5': 9, '8': {}, '10': 'csvColumns'}, { - '1': 'poll_jitter_pct', - '3': 221, + '1': 's3_upload_max_attempts', + '3': 114, '4': 1, '5': 13, '8': {}, - '10': 'pollJitterPct' + '10': 's3UploadMaxAttempts' }, { - '1': 's3_flush_interval', - '3': 222, + '1': 's3_upload_backoff_cap', + '3': 115, '4': 1, '5': 11, '6': '.google.protobuf.Duration', '8': {}, - '10': 's3FlushInterval' + '10': 's3UploadBackoffCap' }, + {'1': 'hostname', '3': 130, '4': 1, '5': 9, '8': {}, '10': 'hostname'}, + {'1': 'location', '3': 131, '4': 1, '5': 9, '8': {}, '10': 'location'}, + {'1': 'label', '3': 132, '4': 1, '5': 9, '8': {}, '10': 'label'}, + {'1': 'tag', '3': 133, '4': 1, '5': 9, '8': {}, '10': 'tag'}, { - '1': 's3_flush_jitter_pct', - '3': 223, + '1': 'daemon_version', + '3': 134, '4': 1, - '5': 13, + '5': 9, '8': {}, - '10': 's3FlushJitterPct' + '10': 'daemonVersion' }, + {'1': 'ipv4_ttl', '3': 150, '4': 1, '5': 13, '8': {}, '10': 'ipv4Ttl'}, { - '1': 's3_flush_threshold_jitter_pct', - '3': 224, + '1': 'ipv6_hop_limit', + '3': 151, '4': 1, '5': 13, '8': {}, - '10': 's3FlushThresholdJitterPct' + '10': 'ipv6HopLimit' }, + {'1': 'grpc_port', '3': 160, '4': 1, '5': 13, '8': {}, '10': 'grpcPort'}, { - '1': 's3_upload_max_attempts', - '3': 225, + '1': 'pyroscope_url', + '3': 170, '4': 1, - '5': 13, + '5': 9, '8': {}, - '10': 's3UploadMaxAttempts' + '10': 'pyroscopeUrl' }, { - '1': 's3_upload_backoff_cap', - '3': 226, + '1': 'pyroscope_app_name', + '3': 171, '4': 1, - '5': 11, - '6': '.google.protobuf.Duration', + '5': 9, '8': {}, - '10': 's3UploadBackoffCap' + '10': 'pyroscopeAppName' }, { - '1': 'reconcile_frequency', - '3': 227, + '1': 'pyroscope_sample_hz', + '3': 172, '4': 1, - '5': 11, - '6': '.google.protobuf.Duration', + '5': 13, '8': {}, - '10': 'reconcileFrequency' + '10': 'pyroscopeSampleHz' }, { - '1': 'reconcile_before_poll', - '3': 228, + '1': 'pyroscope_upload_interval_sec', + '3': 173, + '4': 1, + '5': 13, + '8': {}, + '10': 'pyroscopeUploadIntervalSec' + }, + { + '1': 'resolve_container_id', + '3': 200, '4': 1, '5': 8, - '10': 'reconcileBeforePoll' + '8': {}, + '10': 'resolveContainerId' }, { '1': 'enrich_container_enable', - '3': 230, + '3': 201, '4': 1, '5': 8, '10': 'enrichContainerEnable' }, { '1': 'docker_socket_path', - '3': 231, + '3': 202, '4': 1, '5': 9, '8': {}, @@ -649,14 +642,14 @@ const XtcpConfig$json = { }, { '1': 'enrich_lldp_enable', - '3': 232, + '3': 210, '4': 1, '5': 8, '10': 'enrichLldpEnable' }, { '1': 'lldpd_socket_path', - '3': 233, + '3': 211, '4': 1, '5': 9, '8': {}, @@ -664,7 +657,7 @@ const XtcpConfig$json = { }, { '1': 'lldpd_version_hint', - '3': 234, + '3': 212, '4': 1, '5': 9, '8': {}, @@ -672,14 +665,14 @@ const XtcpConfig$json = { }, { '1': 'enrich_nic_enable', - '3': 235, + '3': 220, '4': 1, '5': 8, '10': 'enrichNicEnable' }, { '1': 'uplink_count', - '3': 236, + '3': 221, '4': 1, '5': 13, '8': {}, @@ -687,24 +680,24 @@ const XtcpConfig$json = { }, { '1': 'uplink_interfaces', - '3': 237, + '3': 222, '4': 3, '5': 9, '8': {}, '10': 'uplinkInterfaces' }, - {'1': 'populate_nsid', '3': 238, '4': 1, '5': 8, '10': 'populateNsid'}, + {'1': 'populate_nsid', '3': 230, '4': 1, '5': 8, '10': 'populateNsid'}, { '1': 'enrich_asn_enable', - '3': 239, + '3': 240, '4': 1, '5': 8, '10': 'enrichAsnEnable' }, - {'1': 'asn_db_path', '3': 240, '4': 1, '5': 9, '8': {}, '10': 'asnDbPath'}, + {'1': 'asn_db_path', '3': 241, '4': 1, '5': 9, '8': {}, '10': 'asnDbPath'}, { '1': 'asn_refresh_interval', - '3': 241, + '3': 242, '4': 1, '5': 11, '6': '.google.protobuf.Duration', @@ -712,14 +705,14 @@ const XtcpConfig$json = { }, { '1': 'enrich_locality_enable', - '3': 242, + '3': 245, '4': 1, '5': 8, '10': 'enrichLocalityEnable' }, { '1': 'locality_refresh_interval', - '3': 243, + '3': 246, '4': 1, '5': 11, '6': '.google.protobuf.Duration', @@ -732,80 +725,80 @@ const XtcpConfig$json = { /// Descriptor for `XtcpConfig`. Decode as a `google.protobuf.DescriptorProto`. final $typed_data.Uint8List xtcpConfigDescriptor = $convert.base64Decode( 'CgpYdGNwQ29uZmlnEkYKF25sX3RpbWVvdXRfbWlsbGlzZWNvbmRzGAogASgEQg66SAvIAQEyBh' - 'igjQYoAFIVbmxUaW1lb3V0TWlsbGlzZWNvbmRzElMKDnBvbGxfZnJlcXVlbmN5GBQgASgLMhku' + 'igjQYoAFIVbmxUaW1lb3V0TWlsbGlzZWNvbmRzElMKDnBvbGxfZnJlcXVlbmN5GAsgASgLMhku' 'Z29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQhG6SA7IAQGqAQgiBAiA9SQqAFINcG9sbEZyZXF1ZW' - '5jeRJPCgxwb2xsX3RpbWVvdXQYHiABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CEbpI' - 'DsgBAaoBCCIECID1JCoAUgtwb2xsVGltZW91dBIrCgltYXhfbG9vcHMYKCABKARCDrpIC8gBAD' - 'IGGKCNBigAUghtYXhMb29wcxIsCgpuZXRsaW5rZXJzGDIgASgNQgy6SAnIAQEqBBhkKAFSCm5l' - 'dGxpbmtlcnMSSAoZbmV0bGlua2Vyc19kb25lX2NoYW5fc2l6ZRgzIAEoDUINukgKyAEBKgUY6A' - 'coAVIWbmV0bGlua2Vyc0RvbmVDaGFuU2l6ZRIqCglubG1zZ19zZXEYPCABKA1CDbpICsgBASoF' - 'GJBOKABSCG5sbXNnU2VxEi8KC3BhY2tldF9zaXplGEYgASgEQg66SAvIAQAyBhjAhD0oAFIKcG' - 'Fja2V0U2l6ZRI2ChBwYWNrZXRfc2l6ZV9tcGx5GFAgASgNQgy6SAnIAQAqBBhkKABSDnBhY2tl' - 'dFNpemVNcGx5Ei4KC3dyaXRlX2ZpbGVzGFogASgNQg26SArIAQAqBRjoBygAUgp3cml0ZUZpbG' - 'VzEi8KDGNhcHR1cmVfcGF0aBhkIAEoCUIMukgJyAEAcgQQARhQUgtjYXB0dXJlUGF0aBIoCgdt' - 'b2R1bHVzGG4gASgEQg66SAvIAQEyBhjAhD0oAVIHbW9kdWx1cxIrCgptYXJzaGFsX3RvGHggAS' - 'gJQgy6SAnIAQFyBBADGChSCW1hcnNoYWxUbxJLCh5lbnZlbG9wZV9mbHVzaF90aHJlc2hvbGRf' - 'Ynl0ZXMYeiABKA1CBrpIA8gBAFIbZW52ZWxvcGVGbHVzaFRocmVzaG9sZEJ5dGVzEkkKHWVudm' - 'Vsb3BlX2ZsdXNoX3RocmVzaG9sZF9yb3dzGHsgASgNQga6SAPIAQBSGmVudmVsb3BlRmx1c2hU' - 'aHJlc2hvbGRSb3dzEjMKEWthZmthX2NvbXByZXNzaW9uGHwgASgJQga6SAPIAQBSEGthZmthQ2' - '9tcHJlc3Npb24SJwoLczNfZW5kcG9pbnQYfSABKAlCBrpIA8gBAFIKczNFbmRwb2ludBIjCglz' - 'M19idWNrZXQYfiABKAlCBrpIA8gBAFIIczNCdWNrZXQSIwoJczNfcHJlZml4GH8gASgJQga6SA' - 'PIAQBSCHMzUHJlZml4EisKDXMzX2FjY2Vzc19rZXkYgAEgASgJQga6SAPIAQBSC3MzQWNjZXNz' - 'S2V5EisKDXMzX3NlY3JldF9rZXkYgQEgASgJQga6SAPIAQBSC3MzU2VjcmV0S2V5Ek8KIHMzX3' - 'BhcnF1ZXRfZmx1c2hfdGhyZXNob2xkX2J5dGVzGIQBIAEoDUIGukgDyAEAUhxzM1BhcnF1ZXRG' - 'bHVzaFRocmVzaG9sZEJ5dGVzEiQKCXMzX3JlZ2lvbhiFASABKAlCBrpIA8gBAFIIczNSZWdpb2' - '4SOAoUczNfc2tpcF9idWNrZXRfcHJvYmUYhgEgASgIQga6SAPIAQBSEXMzU2tpcEJ1Y2tldFBy' - 'b2JlEiwKDXB5cm9zY29wZV91cmwYiAEgASgJQga6SAPIAQBSDHB5cm9zY29wZVVybBI1ChJweX' - 'Jvc2NvcGVfYXBwX25hbWUYiQEgASgJQga6SAPIAQBSEHB5cm9zY29wZUFwcE5hbWUSNwoTcHly' - 'b3Njb3BlX3NhbXBsZV9oehiKASABKA1CBrpIA8gBAFIRcHlyb3Njb3BlU2FtcGxlSHoSSgodcH' - 'lyb3Njb3BlX3VwbG9hZF9pbnRlcnZhbF9zZWMYiwEgASgNQga6SAPIAQBSGnB5cm9zY29wZVVw' - 'bG9hZEludGVydmFsU2VjEiIKBGRlc3QYggEgASgJQg26SArIAQFyBRAEGIAEUgRkZXN0EjgKEG' - 'Rlc3Rfd3JpdGVfZmlsZXMYhwEgASgNQg26SArIAQAqBRjoBygAUg5kZXN0V3JpdGVGaWxlcxIj' - 'CgV0b3BpYxiMASABKAlCDLpICcgBAHIEEAEYKFIFdG9waWMSNQoPeHRjcF9wcm90b19maWxlGI' - '8BIAEoCUIMukgJyAEAcgQQARhQUg14dGNwUHJvdG9GaWxlEjcKEGthZmthX3NjaGVtYV91cmwY' - 'kQEgASgJQgy6SAnIAQByBBABGDxSDmthZmthU2NoZW1hVXJsEmAKFWthZmthX3Byb2R1Y2VfdG' - 'ltZW91dBiWASABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CELpIDcgBAKoBByIDCNgE' - 'MgBSE2thZmthUHJvZHVjZVRpbWVvdXQSLwoLZGVidWdfbGV2ZWwYoAEgASgNQg26SArIAQEqBR' - 'joBygAUgpkZWJ1Z0xldmVsEiEKBWxhYmVsGKoBIAEoCUIKukgHyAEAcgIYKFIFbGFiZWwSHQoD' - 'dGFnGLQBIAEoCUIKukgHyAEAcgIYKFIDdGFnEigKCGxvY2F0aW9uGLUBIAEoCUILukgIyAEAcg' - 'MY/QFSCGxvY2F0aW9uEigKCGhvc3RuYW1lGLYBIAEoCUILukgIyAEAcgMY/QFSCGhvc3RuYW1l' - 'EjMKDmRhZW1vbl92ZXJzaW9uGLoBIAEoCUILukgIyAEAcgMY/QFSDWRhZW1vblZlcnNpb24SOQ' - 'oUcmVzb2x2ZV9jb250YWluZXJfaWQYtwEgASgIQga6SAPIAQBSEnJlc29sdmVDb250YWluZXJJ' - 'ZBInCghpcHY0X3R0bBi4ASABKA1CC7pICMgBACoDGP8BUgdpcHY0VHRsEjIKDmlwdjZfaG9wX2' - 'xpbWl0GLkBIAEoDUILukgIyAEAKgMY/wFSDGlwdjZIb3BMaW1pdBIsCglncnBjX3BvcnQYvgEg' - 'ASgNQg66SAvIAQEqBhj//wMoAVIIZ3JwY1BvcnQSYgoVZW5hYmxlZF9kZXNlcmlhbGl6ZXJzGM' - 'gBIAEoCzIkLnh0Y3BfY29uZmlnLnYxLkVuYWJsZWREZXNlcmlhbGl6ZXJzQga6SAPIAQBSFGVu' - 'YWJsZWREZXNlcmlhbGl6ZXJzEiIKCGlvX3VyaW5nGNIBIAEoCEIGukgDyAEAUgdpb1VyaW5nEk' - 'YKGGlvX3VyaW5nX3JlY3ZfYmF0Y2hfc2l6ZRjTASABKA1CDbpICsgBACoFGIAgKAFSFGlvVXJp' - 'bmdSZWN2QmF0Y2hTaXplEkQKF2lvX3VyaW5nX2NxZV9iYXRjaF9zaXplGNQBIAEoDUINukgKyA' - 'EAKgUYgCAoAVITaW9VcmluZ0NxZUJhdGNoU2l6ZRIoCgtjc3ZfY29sdW1ucxjcASABKAlCBrpI' - 'A8gBAFIKY3N2Q29sdW1ucxIzCg9wb2xsX2ppdHRlcl9wY3QY3QEgASgNQgq6SAfIAQAqAhhkUg' - '1wb2xsSml0dGVyUGN0ElMKEXMzX2ZsdXNoX2ludGVydmFsGN4BIAEoCzIZLmdvb2dsZS5wcm90' - 'b2J1Zi5EdXJhdGlvbkILukgIyAEAqgECMgBSD3MzRmx1c2hJbnRlcnZhbBI6ChNzM19mbHVzaF' - '9qaXR0ZXJfcGN0GN8BIAEoDUIKukgHyAEAKgIYZFIQczNGbHVzaEppdHRlclBjdBJNCh1zM19m' - 'bHVzaF90aHJlc2hvbGRfaml0dGVyX3BjdBjgASABKA1CCrpIB8gBACoCGGRSGXMzRmx1c2hUaH' - 'Jlc2hvbGRKaXR0ZXJQY3QSQgoWczNfdXBsb2FkX21heF9hdHRlbXB0cxjhASABKA1CDLpICcgB' - 'ACoEGGQoAVITczNVcGxvYWRNYXhBdHRlbXB0cxJaChVzM191cGxvYWRfYmFja29mZl9jYXAY4g' - 'EgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQgu6SAjIAQCqAQIyAFISczNVcGxvYWRC' - 'YWNrb2ZmQ2FwElgKE3JlY29uY2lsZV9mcmVxdWVuY3kY4wEgASgLMhkuZ29vZ2xlLnByb3RvYn' - 'VmLkR1cmF0aW9uQgu6SAjIAQCqAQIyAFIScmVjb25jaWxlRnJlcXVlbmN5EjMKFXJlY29uY2ls' - 'ZV9iZWZvcmVfcG9sbBjkASABKAhSE3JlY29uY2lsZUJlZm9yZVBvbGwSNwoXZW5yaWNoX2Nvbn' - 'RhaW5lcl9lbmFibGUY5gEgASgIUhVlbnJpY2hDb250YWluZXJFbmFibGUSNwoSZG9ja2VyX3Nv' - 'Y2tldF9wYXRoGOcBIAEoCUIIukgFcgMY/wFSEGRvY2tlclNvY2tldFBhdGgSLQoSZW5yaWNoX2' - 'xsZHBfZW5hYmxlGOgBIAEoCFIQZW5yaWNoTGxkcEVuYWJsZRI1ChFsbGRwZF9zb2NrZXRfcGF0' - 'aBjpASABKAlCCLpIBXIDGP8BUg9sbGRwZFNvY2tldFBhdGgSNgoSbGxkcGRfdmVyc2lvbl9oaW' - '50GOoBIAEoCUIHukgEcgIYEFIQbGxkcGRWZXJzaW9uSGludBIrChFlbnJpY2hfbmljX2VuYWJs' - 'ZRjrASABKAhSD2VucmljaE5pY0VuYWJsZRIrCgx1cGxpbmtfY291bnQY7AEgASgNQge6SAQqAh' - 'gCUgt1cGxpbmtDb3VudBI2ChF1cGxpbmtfaW50ZXJmYWNlcxjtASADKAlCCLpIBZIBAhACUhB1' - 'cGxpbmtJbnRlcmZhY2VzEiQKDXBvcHVsYXRlX25zaWQY7gEgASgIUgxwb3B1bGF0ZU5zaWQSKw' - 'oRZW5yaWNoX2Fzbl9lbmFibGUY7wEgASgIUg9lbnJpY2hBc25FbmFibGUSKQoLYXNuX2RiX3Bh' - 'dGgY8AEgASgJQgi6SAVyAxj/AVIJYXNuRGJQYXRoEkwKFGFzbl9yZWZyZXNoX2ludGVydmFsGP' - 'EBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvblISYXNuUmVmcmVzaEludGVydmFsEjUK' - 'FmVucmljaF9sb2NhbGl0eV9lbmFibGUY8gEgASgIUhRlbnJpY2hMb2NhbGl0eUVuYWJsZRJWCh' - 'lsb2NhbGl0eV9yZWZyZXNoX2ludGVydmFsGPMBIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJh' - 'dGlvblIXbG9jYWxpdHlSZWZyZXNoSW50ZXJ2YWw6c7pIcBpuCg9YdGNwQ29uZmlnLnBvbGwSMl' - 'BvbGwgdGltZW91dCBtdXN0IGJlIGxlc3MgdGhhbiBwb2xsIHBvbGxfZnJlcXVlbmN5Gid0aGlz' - 'LnBvbGxfZnJlcXVlbmN5ID4gdGhpcy5wb2xsX3RpbWVvdXQ='); + '5jeRJPCgxwb2xsX3RpbWVvdXQYDCABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CEbpI' + 'DsgBAaoBCCIECID1JCoAUgtwb2xsVGltZW91dBIyCg9wb2xsX2ppdHRlcl9wY3QYDSABKA1CCr' + 'pIB8gBACoCGGRSDXBvbGxKaXR0ZXJQY3QSKwoJbWF4X2xvb3BzGA4gASgEQg66SAvIAQAyBhig' + 'jQYoAFIIbWF4TG9vcHMSLAoKbmV0bGlua2VycxgPIAEoDUIMukgJyAEBKgQYZCgBUgpuZXRsaW' + '5rZXJzEkgKGW5ldGxpbmtlcnNfZG9uZV9jaGFuX3NpemUYECABKA1CDbpICsgBASoFGOgHKAFS' + 'Fm5ldGxpbmtlcnNEb25lQ2hhblNpemUSKgoJbmxtc2dfc2VxGBEgASgNQg26SArIAQEqBRiQTi' + 'gAUghubG1zZ1NlcRIvCgtwYWNrZXRfc2l6ZRgSIAEoBEIOukgLyAEAMgYYwIQ9KABSCnBhY2tl' + 'dFNpemUSNgoQcGFja2V0X3NpemVfbXBseRgTIAEoDUIMukgJyAEAKgQYZCgAUg5wYWNrZXRTaX' + 'plTXBseRIoCgdtb2R1bHVzGBQgASgEQg66SAvIAQEyBhjAhD0oAVIHbW9kdWx1cxJhChVlbmFi' + 'bGVkX2Rlc2VyaWFsaXplcnMYFSABKAsyJC54dGNwX2NvbmZpZy52MS5FbmFibGVkRGVzZXJpYW' + 'xpemVyc0IGukgDyAEAUhRlbmFibGVkRGVzZXJpYWxpemVycxIhCghpb191cmluZxgWIAEoCEIG' + 'ukgDyAEAUgdpb1VyaW5nEkUKGGlvX3VyaW5nX3JlY3ZfYmF0Y2hfc2l6ZRgXIAEoDUINukgKyA' + 'EAKgUYgCAoAVIUaW9VcmluZ1JlY3ZCYXRjaFNpemUSQwoXaW9fdXJpbmdfY3FlX2JhdGNoX3Np' + 'emUYGCABKA1CDbpICsgBACoFGIAgKAFSE2lvVXJpbmdDcWVCYXRjaFNpemUSVwoTcmVjb25jaW' + 'xlX2ZyZXF1ZW5jeRgoIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkILukgIyAEAqgEC' + 'MgBSEnJlY29uY2lsZUZyZXF1ZW5jeRIyChVyZWNvbmNpbGVfYmVmb3JlX3BvbGwYKSABKAhSE3' + 'JlY29uY2lsZUJlZm9yZVBvbGwSLgoLd3JpdGVfZmlsZXMYMiABKA1CDbpICsgBACoFGOgHKABS' + 'CndyaXRlRmlsZXMSLwoMY2FwdHVyZV9wYXRoGDMgASgJQgy6SAnIAQByBBABGFBSC2NhcHR1cm' + 'VQYXRoEjcKEGRlc3Rfd3JpdGVfZmlsZXMYNCABKA1CDbpICsgBACoFGOgHKABSDmRlc3RXcml0' + 'ZUZpbGVzEi4KC2RlYnVnX2xldmVsGDUgASgNQg26SArIAQEqBRjoBygAUgpkZWJ1Z0xldmVsEi' + 'EKBGRlc3QYPCABKAlCDbpICsgBAXIFEAQYgARSBGRlc3QSKwoKbWFyc2hhbF90bxg9IAEoCUIM' + 'ukgJyAEBcgQQAxgoUgltYXJzaGFsVG8SJwoLY3N2X2NvbHVtbnMYPiABKAlCBrpIA8gBAFIKY3' + 'N2Q29sdW1ucxI0Cg94dGNwX3Byb3RvX2ZpbGUYPyABKAlCDLpICcgBAHIEEAEYUFINeHRjcFBy' + 'b3RvRmlsZRJLCh5lbnZlbG9wZV9mbHVzaF90aHJlc2hvbGRfYnl0ZXMYQCABKA1CBrpIA8gBAF' + 'IbZW52ZWxvcGVGbHVzaFRocmVzaG9sZEJ5dGVzEkkKHWVudmVsb3BlX2ZsdXNoX3RocmVzaG9s' + 'ZF9yb3dzGEEgASgNQga6SAPIAQBSGmVudmVsb3BlRmx1c2hUaHJlc2hvbGRSb3dzEiIKBXRvcG' + 'ljGFAgASgJQgy6SAnIAQByBBABGChSBXRvcGljEjYKEGthZmthX3NjaGVtYV91cmwYUSABKAlC' + 'DLpICcgBAHIEEAEYPFIOa2Fma2FTY2hlbWFVcmwSXwoVa2Fma2FfcHJvZHVjZV90aW1lb3V0GF' + 'IgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQhC6SA3IAQCqAQciAwjYBDIAUhNrYWZr' + 'YVByb2R1Y2VUaW1lb3V0EjMKEWthZmthX2NvbXByZXNzaW9uGFMgASgJQga6SAPIAQBSEGthZm' + 'thQ29tcHJlc3Npb24SJwoLczNfZW5kcG9pbnQYZCABKAlCBrpIA8gBAFIKczNFbmRwb2ludBIj' + 'CglzM19yZWdpb24YZSABKAlCBrpIA8gBAFIIczNSZWdpb24SIwoJczNfYnVja2V0GGYgASgJQg' + 'a6SAPIAQBSCHMzQnVja2V0EiMKCXMzX3ByZWZpeBhnIAEoCUIGukgDyAEAUghzM1ByZWZpeBIq' + 'Cg1zM19hY2Nlc3Nfa2V5GGggASgJQga6SAPIAQBSC3MzQWNjZXNzS2V5EioKDXMzX3NlY3JldF' + '9rZXkYaSABKAlCBrpIA8gBAFILczNTZWNyZXRLZXkSNwoUczNfc2tpcF9idWNrZXRfcHJvYmUY' + 'aiABKAhCBrpIA8gBAFIRczNTa2lwQnVja2V0UHJvYmUSTgogczNfcGFycXVldF9mbHVzaF90aH' + 'Jlc2hvbGRfYnl0ZXMYbiABKA1CBrpIA8gBAFIcczNQYXJxdWV0Rmx1c2hUaHJlc2hvbGRCeXRl' + 'cxJSChFzM19mbHVzaF9pbnRlcnZhbBhvIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbk' + 'ILukgIyAEAqgECMgBSD3MzRmx1c2hJbnRlcnZhbBI5ChNzM19mbHVzaF9qaXR0ZXJfcGN0GHAg' + 'ASgNQgq6SAfIAQAqAhhkUhBzM0ZsdXNoSml0dGVyUGN0EkwKHXMzX2ZsdXNoX3RocmVzaG9sZF' + '9qaXR0ZXJfcGN0GHEgASgNQgq6SAfIAQAqAhhkUhlzM0ZsdXNoVGhyZXNob2xkSml0dGVyUGN0' + 'EkEKFnMzX3VwbG9hZF9tYXhfYXR0ZW1wdHMYciABKA1CDLpICcgBACoEGGQoAVITczNVcGxvYW' + 'RNYXhBdHRlbXB0cxJZChVzM191cGxvYWRfYmFja29mZl9jYXAYcyABKAsyGS5nb29nbGUucHJv' + 'dG9idWYuRHVyYXRpb25CC7pICMgBAKoBAjIAUhJzM1VwbG9hZEJhY2tvZmZDYXASKAoIaG9zdG' + '5hbWUYggEgASgJQgu6SAjIAQByAxj9AVIIaG9zdG5hbWUSKAoIbG9jYXRpb24YgwEgASgJQgu6' + 'SAjIAQByAxj9AVIIbG9jYXRpb24SIQoFbGFiZWwYhAEgASgJQgq6SAfIAQByAhgoUgVsYWJlbB' + 'IdCgN0YWcYhQEgASgJQgq6SAfIAQByAhgoUgN0YWcSMwoOZGFlbW9uX3ZlcnNpb24YhgEgASgJ' + 'Qgu6SAjIAQByAxj9AVINZGFlbW9uVmVyc2lvbhInCghpcHY0X3R0bBiWASABKA1CC7pICMgBAC' + 'oDGP8BUgdpcHY0VHRsEjIKDmlwdjZfaG9wX2xpbWl0GJcBIAEoDUILukgIyAEAKgMY/wFSDGlw' + 'djZIb3BMaW1pdBIsCglncnBjX3BvcnQYoAEgASgNQg66SAvIAQEqBhj//wMoAVIIZ3JwY1Bvcn' + 'QSLAoNcHlyb3Njb3BlX3VybBiqASABKAlCBrpIA8gBAFIMcHlyb3Njb3BlVXJsEjUKEnB5cm9z' + 'Y29wZV9hcHBfbmFtZRirASABKAlCBrpIA8gBAFIQcHlyb3Njb3BlQXBwTmFtZRI3ChNweXJvc2' + 'NvcGVfc2FtcGxlX2h6GKwBIAEoDUIGukgDyAEAUhFweXJvc2NvcGVTYW1wbGVIehJKCh1weXJv' + 'c2NvcGVfdXBsb2FkX2ludGVydmFsX3NlYxitASABKA1CBrpIA8gBAFIacHlyb3Njb3BlVXBsb2' + 'FkSW50ZXJ2YWxTZWMSOQoUcmVzb2x2ZV9jb250YWluZXJfaWQYyAEgASgIQga6SAPIAQBSEnJl' + 'c29sdmVDb250YWluZXJJZBI3ChdlbnJpY2hfY29udGFpbmVyX2VuYWJsZRjJASABKAhSFWVucm' + 'ljaENvbnRhaW5lckVuYWJsZRI3ChJkb2NrZXJfc29ja2V0X3BhdGgYygEgASgJQgi6SAVyAxj/' + 'AVIQZG9ja2VyU29ja2V0UGF0aBItChJlbnJpY2hfbGxkcF9lbmFibGUY0gEgASgIUhBlbnJpY2' + 'hMbGRwRW5hYmxlEjUKEWxsZHBkX3NvY2tldF9wYXRoGNMBIAEoCUIIukgFcgMY/wFSD2xsZHBk' + 'U29ja2V0UGF0aBI2ChJsbGRwZF92ZXJzaW9uX2hpbnQY1AEgASgJQge6SARyAhgQUhBsbGRwZF' + 'ZlcnNpb25IaW50EisKEWVucmljaF9uaWNfZW5hYmxlGNwBIAEoCFIPZW5yaWNoTmljRW5hYmxl' + 'EisKDHVwbGlua19jb3VudBjdASABKA1CB7pIBCoCGAJSC3VwbGlua0NvdW50EjYKEXVwbGlua1' + '9pbnRlcmZhY2VzGN4BIAMoCUIIukgFkgECEAJSEHVwbGlua0ludGVyZmFjZXMSJAoNcG9wdWxh' + 'dGVfbnNpZBjmASABKAhSDHBvcHVsYXRlTnNpZBIrChFlbnJpY2hfYXNuX2VuYWJsZRjwASABKA' + 'hSD2VucmljaEFzbkVuYWJsZRIpCgthc25fZGJfcGF0aBjxASABKAlCCLpIBXIDGP8BUglhc25E' + 'YlBhdGgSTAoUYXNuX3JlZnJlc2hfaW50ZXJ2YWwY8gEgASgLMhkuZ29vZ2xlLnByb3RvYnVmLk' + 'R1cmF0aW9uUhJhc25SZWZyZXNoSW50ZXJ2YWwSNQoWZW5yaWNoX2xvY2FsaXR5X2VuYWJsZRj1' + 'ASABKAhSFGVucmljaExvY2FsaXR5RW5hYmxlElYKGWxvY2FsaXR5X3JlZnJlc2hfaW50ZXJ2YW' + 'wY9gEgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uUhdsb2NhbGl0eVJlZnJlc2hJbnRl' + 'cnZhbDpzukhwGm4KD1h0Y3BDb25maWcucG9sbBIyUG9sbCB0aW1lb3V0IG11c3QgYmUgbGVzcy' + 'B0aGFuIHBvbGwgcG9sbF9mcmVxdWVuY3kaJ3RoaXMucG9sbF9mcmVxdWVuY3kgPiB0aGlzLnBv' + 'bGxfdGltZW91dA=='); @$core.Deprecated('Use enabledDeserializersDescriptor instead') const EnabledDeserializers$json = { diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart index 5929dc8..d98b53e 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pb.dart @@ -72,11 +72,7 @@ class Envelope extends $pb.GeneratedMessage { $pb.PbList get row => $_getList(0); } -/// Field-number layout (reorganised 2026-08 while the record had few consumers): -/// metadata ... 1-999 (identity + per-uplink network topology) -/// payload ... 1000+ (kernel inet_diag subsystems, one hundred-block each) -/// ClickHouse's Protobuf format maps columns by field NAME and Parquet uses its own -/// schema, so the wire-tag renumber does not break ingestion or historical Parquet. +/// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information class XtcpFlatRecord extends $pb.GeneratedMessage { factory XtcpFlatRecord({ $core.int? schemaVersion, @@ -122,6 +118,13 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.String? uplink2LldpMgmtIp, $core.String? uplink2LldpPortId, $core.String? uplink2LldpPortDescr, + $core.String? enrichSocketInterfaceName, + XtcpFlatRecord_Locality? enrichSocketDestLocality, + $core.int? enrichSocketDestEgressIfindex, + $core.String? enrichSocketDestEgressIfname, + $fixnum.Int64? enrichSocketDestAsn, + $fixnum.Int64? enrichSocketDestNextHopAsn, + $core.String? enrichSocketDestNetworkOwner, $core.int? inetDiagMsgFamily, $core.int? inetDiagMsgState, $core.int? inetDiagMsgTimer, @@ -132,15 +135,11 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.List<$core.int>? inetDiagMsgSocketDestination, $core.int? inetDiagMsgSocketInterface, $fixnum.Int64? inetDiagMsgSocketCookie, - $fixnum.Int64? inetDiagMsgSocketDestAsn, - $fixnum.Int64? inetDiagMsgSocketNextHopAsn, $core.int? inetDiagMsgExpires, $core.int? inetDiagMsgRqueue, $core.int? inetDiagMsgWqueue, $core.int? inetDiagMsgUid, $core.int? inetDiagMsgInode, - $core.String? inetDiagMsgSocketDestNetworkOwner, - XtcpFlatRecord_Locality? inetDiagMsgSocketDestLocality, $core.int? memInfoRmem, $core.int? memInfoWmem, $core.int? memInfoFmem, @@ -151,10 +150,10 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? tcpInfoProbes, $core.int? tcpInfoBackoff, $core.int? tcpInfoOptions, - $core.int? tcpInfoSendScale, - $core.int? tcpInfoRcvScale, + $core.int? tcpInfoSndWscale, + $core.int? tcpInfoRcvWscale, $core.int? tcpInfoDeliveryRateAppLimited, - $core.int? tcpInfoFastOpenClientFailed, + $core.int? tcpInfoFastopenClientFail, $core.int? tcpInfoRto, $core.int? tcpInfoAto, $core.int? tcpInfoSndMss, @@ -171,10 +170,10 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? tcpInfoPmtu, $core.int? tcpInfoRcvSsthresh, $core.int? tcpInfoRtt, - $core.int? tcpInfoRttVar, + $core.int? tcpInfoRttvar, $core.int? tcpInfoSndSsthresh, $core.int? tcpInfoSndCwnd, - $core.int? tcpInfoAdvMss, + $core.int? tcpInfoAdvmss, $core.int? tcpInfoReordering, $core.int? tcpInfoRcvRtt, $core.int? tcpInfoRcvSpace, @@ -185,7 +184,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $fixnum.Int64? tcpInfoBytesReceived, $core.int? tcpInfoSegsOut, $core.int? tcpInfoSegsIn, - $core.int? tcpInfoNotSentBytes, + $core.int? tcpInfoNotsentBytes, $core.int? tcpInfoMinRtt, $core.int? tcpInfoDataSegsIn, $core.int? tcpInfoDataSegsOut, @@ -206,24 +205,24 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? tcpInfoTotalRto, $core.int? tcpInfoTotalRtoRecoveries, $core.int? tcpInfoTotalRtoTime, - $core.String? congestionAlgorithmString, - XtcpFlatRecord_CongestionAlgorithm? congestionAlgorithmEnum, - $core.int? typeOfService, - $core.int? trafficClass, + $core.String? inetDiagCong, + XtcpFlatRecord_CongestionAlgorithm? inetDiagCongEnum, + $core.int? inetDiagTos, + $core.int? inetDiagTclass, $core.int? skMemInfoRmemAlloc, - $core.int? skMemInfoRcvBuf, + $core.int? skMemInfoRcvbuf, $core.int? skMemInfoWmemAlloc, - $core.int? skMemInfoSndBuf, + $core.int? skMemInfoSndbuf, $core.int? skMemInfoFwdAlloc, $core.int? skMemInfoWmemQueued, $core.int? skMemInfoOptmem, $core.int? skMemInfoBacklog, $core.int? skMemInfoDrops, - $core.int? shutdownState, + $core.int? inetDiagShutdown, $core.int? vegasInfoEnabled, - $core.int? vegasInfoRttCnt, + $core.int? vegasInfoRttcnt, $core.int? vegasInfoRtt, - $core.int? vegasInfoMinRtt, + $core.int? vegasInfoMinrtt, $core.int? dctcpInfoEnabled, $core.int? dctcpInfoCeState, $core.int? dctcpInfoAlpha, @@ -234,9 +233,9 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { $core.int? bbrInfoMinRtt, $core.int? bbrInfoPacingGain, $core.int? bbrInfoCwndGain, - $core.int? classId, - $core.int? sockOpt, - $fixnum.Int64? cGroup, + $core.int? inetDiagClassId, + $core.int? inetDiagSockopt, + $fixnum.Int64? inetDiagCgroupId, }) { final result = create(); if (schemaVersion != null) result.schemaVersion = schemaVersion; @@ -296,6 +295,20 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (uplink2LldpPortId != null) result.uplink2LldpPortId = uplink2LldpPortId; if (uplink2LldpPortDescr != null) result.uplink2LldpPortDescr = uplink2LldpPortDescr; + if (enrichSocketInterfaceName != null) + result.enrichSocketInterfaceName = enrichSocketInterfaceName; + if (enrichSocketDestLocality != null) + result.enrichSocketDestLocality = enrichSocketDestLocality; + if (enrichSocketDestEgressIfindex != null) + result.enrichSocketDestEgressIfindex = enrichSocketDestEgressIfindex; + if (enrichSocketDestEgressIfname != null) + result.enrichSocketDestEgressIfname = enrichSocketDestEgressIfname; + if (enrichSocketDestAsn != null) + result.enrichSocketDestAsn = enrichSocketDestAsn; + if (enrichSocketDestNextHopAsn != null) + result.enrichSocketDestNextHopAsn = enrichSocketDestNextHopAsn; + if (enrichSocketDestNetworkOwner != null) + result.enrichSocketDestNetworkOwner = enrichSocketDestNetworkOwner; if (inetDiagMsgFamily != null) result.inetDiagMsgFamily = inetDiagMsgFamily; if (inetDiagMsgState != null) result.inetDiagMsgState = inetDiagMsgState; if (inetDiagMsgTimer != null) result.inetDiagMsgTimer = inetDiagMsgTimer; @@ -314,21 +327,12 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { result.inetDiagMsgSocketInterface = inetDiagMsgSocketInterface; if (inetDiagMsgSocketCookie != null) result.inetDiagMsgSocketCookie = inetDiagMsgSocketCookie; - if (inetDiagMsgSocketDestAsn != null) - result.inetDiagMsgSocketDestAsn = inetDiagMsgSocketDestAsn; - if (inetDiagMsgSocketNextHopAsn != null) - result.inetDiagMsgSocketNextHopAsn = inetDiagMsgSocketNextHopAsn; if (inetDiagMsgExpires != null) result.inetDiagMsgExpires = inetDiagMsgExpires; if (inetDiagMsgRqueue != null) result.inetDiagMsgRqueue = inetDiagMsgRqueue; if (inetDiagMsgWqueue != null) result.inetDiagMsgWqueue = inetDiagMsgWqueue; if (inetDiagMsgUid != null) result.inetDiagMsgUid = inetDiagMsgUid; if (inetDiagMsgInode != null) result.inetDiagMsgInode = inetDiagMsgInode; - if (inetDiagMsgSocketDestNetworkOwner != null) - result.inetDiagMsgSocketDestNetworkOwner = - inetDiagMsgSocketDestNetworkOwner; - if (inetDiagMsgSocketDestLocality != null) - result.inetDiagMsgSocketDestLocality = inetDiagMsgSocketDestLocality; if (memInfoRmem != null) result.memInfoRmem = memInfoRmem; if (memInfoWmem != null) result.memInfoWmem = memInfoWmem; if (memInfoFmem != null) result.memInfoFmem = memInfoFmem; @@ -340,12 +344,12 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (tcpInfoProbes != null) result.tcpInfoProbes = tcpInfoProbes; if (tcpInfoBackoff != null) result.tcpInfoBackoff = tcpInfoBackoff; if (tcpInfoOptions != null) result.tcpInfoOptions = tcpInfoOptions; - if (tcpInfoSendScale != null) result.tcpInfoSendScale = tcpInfoSendScale; - if (tcpInfoRcvScale != null) result.tcpInfoRcvScale = tcpInfoRcvScale; + if (tcpInfoSndWscale != null) result.tcpInfoSndWscale = tcpInfoSndWscale; + if (tcpInfoRcvWscale != null) result.tcpInfoRcvWscale = tcpInfoRcvWscale; if (tcpInfoDeliveryRateAppLimited != null) result.tcpInfoDeliveryRateAppLimited = tcpInfoDeliveryRateAppLimited; - if (tcpInfoFastOpenClientFailed != null) - result.tcpInfoFastOpenClientFailed = tcpInfoFastOpenClientFailed; + if (tcpInfoFastopenClientFail != null) + result.tcpInfoFastopenClientFail = tcpInfoFastopenClientFail; if (tcpInfoRto != null) result.tcpInfoRto = tcpInfoRto; if (tcpInfoAto != null) result.tcpInfoAto = tcpInfoAto; if (tcpInfoSndMss != null) result.tcpInfoSndMss = tcpInfoSndMss; @@ -367,11 +371,11 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (tcpInfoRcvSsthresh != null) result.tcpInfoRcvSsthresh = tcpInfoRcvSsthresh; if (tcpInfoRtt != null) result.tcpInfoRtt = tcpInfoRtt; - if (tcpInfoRttVar != null) result.tcpInfoRttVar = tcpInfoRttVar; + if (tcpInfoRttvar != null) result.tcpInfoRttvar = tcpInfoRttvar; if (tcpInfoSndSsthresh != null) result.tcpInfoSndSsthresh = tcpInfoSndSsthresh; if (tcpInfoSndCwnd != null) result.tcpInfoSndCwnd = tcpInfoSndCwnd; - if (tcpInfoAdvMss != null) result.tcpInfoAdvMss = tcpInfoAdvMss; + if (tcpInfoAdvmss != null) result.tcpInfoAdvmss = tcpInfoAdvmss; if (tcpInfoReordering != null) result.tcpInfoReordering = tcpInfoReordering; if (tcpInfoRcvRtt != null) result.tcpInfoRcvRtt = tcpInfoRcvRtt; if (tcpInfoRcvSpace != null) result.tcpInfoRcvSpace = tcpInfoRcvSpace; @@ -385,8 +389,8 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { result.tcpInfoBytesReceived = tcpInfoBytesReceived; if (tcpInfoSegsOut != null) result.tcpInfoSegsOut = tcpInfoSegsOut; if (tcpInfoSegsIn != null) result.tcpInfoSegsIn = tcpInfoSegsIn; - if (tcpInfoNotSentBytes != null) - result.tcpInfoNotSentBytes = tcpInfoNotSentBytes; + if (tcpInfoNotsentBytes != null) + result.tcpInfoNotsentBytes = tcpInfoNotsentBytes; if (tcpInfoMinRtt != null) result.tcpInfoMinRtt = tcpInfoMinRtt; if (tcpInfoDataSegsIn != null) result.tcpInfoDataSegsIn = tcpInfoDataSegsIn; if (tcpInfoDataSegsOut != null) @@ -415,29 +419,27 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { result.tcpInfoTotalRtoRecoveries = tcpInfoTotalRtoRecoveries; if (tcpInfoTotalRtoTime != null) result.tcpInfoTotalRtoTime = tcpInfoTotalRtoTime; - if (congestionAlgorithmString != null) - result.congestionAlgorithmString = congestionAlgorithmString; - if (congestionAlgorithmEnum != null) - result.congestionAlgorithmEnum = congestionAlgorithmEnum; - if (typeOfService != null) result.typeOfService = typeOfService; - if (trafficClass != null) result.trafficClass = trafficClass; + if (inetDiagCong != null) result.inetDiagCong = inetDiagCong; + if (inetDiagCongEnum != null) result.inetDiagCongEnum = inetDiagCongEnum; + if (inetDiagTos != null) result.inetDiagTos = inetDiagTos; + if (inetDiagTclass != null) result.inetDiagTclass = inetDiagTclass; if (skMemInfoRmemAlloc != null) result.skMemInfoRmemAlloc = skMemInfoRmemAlloc; - if (skMemInfoRcvBuf != null) result.skMemInfoRcvBuf = skMemInfoRcvBuf; + if (skMemInfoRcvbuf != null) result.skMemInfoRcvbuf = skMemInfoRcvbuf; if (skMemInfoWmemAlloc != null) result.skMemInfoWmemAlloc = skMemInfoWmemAlloc; - if (skMemInfoSndBuf != null) result.skMemInfoSndBuf = skMemInfoSndBuf; + if (skMemInfoSndbuf != null) result.skMemInfoSndbuf = skMemInfoSndbuf; if (skMemInfoFwdAlloc != null) result.skMemInfoFwdAlloc = skMemInfoFwdAlloc; if (skMemInfoWmemQueued != null) result.skMemInfoWmemQueued = skMemInfoWmemQueued; if (skMemInfoOptmem != null) result.skMemInfoOptmem = skMemInfoOptmem; if (skMemInfoBacklog != null) result.skMemInfoBacklog = skMemInfoBacklog; if (skMemInfoDrops != null) result.skMemInfoDrops = skMemInfoDrops; - if (shutdownState != null) result.shutdownState = shutdownState; + if (inetDiagShutdown != null) result.inetDiagShutdown = inetDiagShutdown; if (vegasInfoEnabled != null) result.vegasInfoEnabled = vegasInfoEnabled; - if (vegasInfoRttCnt != null) result.vegasInfoRttCnt = vegasInfoRttCnt; + if (vegasInfoRttcnt != null) result.vegasInfoRttcnt = vegasInfoRttcnt; if (vegasInfoRtt != null) result.vegasInfoRtt = vegasInfoRtt; - if (vegasInfoMinRtt != null) result.vegasInfoMinRtt = vegasInfoMinRtt; + if (vegasInfoMinrtt != null) result.vegasInfoMinrtt = vegasInfoMinrtt; if (dctcpInfoEnabled != null) result.dctcpInfoEnabled = dctcpInfoEnabled; if (dctcpInfoCeState != null) result.dctcpInfoCeState = dctcpInfoCeState; if (dctcpInfoAlpha != null) result.dctcpInfoAlpha = dctcpInfoAlpha; @@ -448,9 +450,9 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { if (bbrInfoMinRtt != null) result.bbrInfoMinRtt = bbrInfoMinRtt; if (bbrInfoPacingGain != null) result.bbrInfoPacingGain = bbrInfoPacingGain; if (bbrInfoCwndGain != null) result.bbrInfoCwndGain = bbrInfoCwndGain; - if (classId != null) result.classId = classId; - if (sockOpt != null) result.sockOpt = sockOpt; - if (cGroup != null) result.cGroup = cGroup; + if (inetDiagClassId != null) result.inetDiagClassId = inetDiagClassId; + if (inetDiagSockopt != null) result.inetDiagSockopt = inetDiagSockopt; + if (inetDiagCgroupId != null) result.inetDiagCgroupId = inetDiagCgroupId; return result; } @@ -526,6 +528,20 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { ..aOS(222, _omitFieldNames ? '' : 'uplink2LldpMgmtIp') ..aOS(223, _omitFieldNames ? '' : 'uplink2LldpPortId') ..aOS(224, _omitFieldNames ? '' : 'uplink2LldpPortDescr') + ..aOS(300, _omitFieldNames ? '' : 'enrichSocketInterfaceName') + ..aE( + 310, _omitFieldNames ? '' : 'enrichSocketDestLocality', + enumValues: XtcpFlatRecord_Locality.values) + ..aI(311, _omitFieldNames ? '' : 'enrichSocketDestEgressIfindex', + fieldType: $pb.PbFieldType.OU3) + ..aOS(312, _omitFieldNames ? '' : 'enrichSocketDestEgressIfname') + ..a<$fixnum.Int64>( + 320, _omitFieldNames ? '' : 'enrichSocketDestAsn', $pb.PbFieldType.OU6, + defaultOrMaker: $fixnum.Int64.ZERO) + ..a<$fixnum.Int64>(321, _omitFieldNames ? '' : 'enrichSocketDestNextHopAsn', + $pb.PbFieldType.OU6, + defaultOrMaker: $fixnum.Int64.ZERO) + ..aOS(322, _omitFieldNames ? '' : 'enrichSocketDestNetworkOwner') ..aI(1001, _omitFieldNames ? '' : 'inetDiagMsgFamily', fieldType: $pb.PbFieldType.OU3) ..aI(1002, _omitFieldNames ? '' : 'inetDiagMsgState', @@ -549,14 +565,6 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { ..a<$fixnum.Int64>(1010, _omitFieldNames ? '' : 'inetDiagMsgSocketCookie', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) - ..a<$fixnum.Int64>(1011, _omitFieldNames ? '' : 'inetDiagMsgSocketDestAsn', - $pb.PbFieldType.OU6, - defaultOrMaker: $fixnum.Int64.ZERO) - ..a<$fixnum.Int64>( - 1012, - _omitFieldNames ? '' : 'inetDiagMsgSocketNextHopAsn', - $pb.PbFieldType.OU6, - defaultOrMaker: $fixnum.Int64.ZERO) ..aI(1013, _omitFieldNames ? '' : 'inetDiagMsgExpires', fieldType: $pb.PbFieldType.OU3) ..aI(1014, _omitFieldNames ? '' : 'inetDiagMsgRqueue', @@ -567,10 +575,6 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1017, _omitFieldNames ? '' : 'inetDiagMsgInode', fieldType: $pb.PbFieldType.OU3) - ..aOS(1018, _omitFieldNames ? '' : 'inetDiagMsgSocketDestNetworkOwner') - ..aE( - 1019, _omitFieldNames ? '' : 'inetDiagMsgSocketDestLocality', - enumValues: XtcpFlatRecord_Locality.values) ..aI(1101, _omitFieldNames ? '' : 'memInfoRmem', fieldType: $pb.PbFieldType.OU3) ..aI(1102, _omitFieldNames ? '' : 'memInfoWmem', @@ -591,13 +595,13 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1206, _omitFieldNames ? '' : 'tcpInfoOptions', fieldType: $pb.PbFieldType.OU3) - ..aI(1207, _omitFieldNames ? '' : 'tcpInfoSendScale', + ..aI(1207, _omitFieldNames ? '' : 'tcpInfoSndWscale', fieldType: $pb.PbFieldType.OU3) - ..aI(1208, _omitFieldNames ? '' : 'tcpInfoRcvScale', + ..aI(1208, _omitFieldNames ? '' : 'tcpInfoRcvWscale', fieldType: $pb.PbFieldType.OU3) ..aI(1209, _omitFieldNames ? '' : 'tcpInfoDeliveryRateAppLimited', fieldType: $pb.PbFieldType.OU3) - ..aI(1210, _omitFieldNames ? '' : 'tcpInfoFastOpenClientFailed', + ..aI(1210, _omitFieldNames ? '' : 'tcpInfoFastopenClientFail', fieldType: $pb.PbFieldType.OU3) ..aI(1215, _omitFieldNames ? '' : 'tcpInfoRto', fieldType: $pb.PbFieldType.OU3) @@ -631,13 +635,13 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1230, _omitFieldNames ? '' : 'tcpInfoRtt', fieldType: $pb.PbFieldType.OU3) - ..aI(1231, _omitFieldNames ? '' : 'tcpInfoRttVar', + ..aI(1231, _omitFieldNames ? '' : 'tcpInfoRttvar', fieldType: $pb.PbFieldType.OU3) ..aI(1232, _omitFieldNames ? '' : 'tcpInfoSndSsthresh', fieldType: $pb.PbFieldType.OU3) ..aI(1233, _omitFieldNames ? '' : 'tcpInfoSndCwnd', fieldType: $pb.PbFieldType.OU3) - ..aI(1234, _omitFieldNames ? '' : 'tcpInfoAdvMss', + ..aI(1234, _omitFieldNames ? '' : 'tcpInfoAdvmss', fieldType: $pb.PbFieldType.OU3) ..aI(1235, _omitFieldNames ? '' : 'tcpInfoReordering', fieldType: $pb.PbFieldType.OU3) @@ -663,7 +667,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1244, _omitFieldNames ? '' : 'tcpInfoSegsIn', fieldType: $pb.PbFieldType.OU3) - ..aI(1245, _omitFieldNames ? '' : 'tcpInfoNotSentBytes', + ..aI(1245, _omitFieldNames ? '' : 'tcpInfoNotsentBytes', fieldType: $pb.PbFieldType.OU3) ..aI(1246, _omitFieldNames ? '' : 'tcpInfoMinRtt', fieldType: $pb.PbFieldType.OU3) @@ -711,21 +715,21 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1265, _omitFieldNames ? '' : 'tcpInfoTotalRtoTime', fieldType: $pb.PbFieldType.OU3) - ..aOS(1300, _omitFieldNames ? '' : 'congestionAlgorithmString') + ..aOS(1300, _omitFieldNames ? '' : 'inetDiagCong') ..aE( - 1301, _omitFieldNames ? '' : 'congestionAlgorithmEnum', + 1301, _omitFieldNames ? '' : 'inetDiagCongEnum', enumValues: XtcpFlatRecord_CongestionAlgorithm.values) - ..aI(1401, _omitFieldNames ? '' : 'typeOfService', + ..aI(1401, _omitFieldNames ? '' : 'inetDiagTos', fieldType: $pb.PbFieldType.OU3) - ..aI(1402, _omitFieldNames ? '' : 'trafficClass', + ..aI(1402, _omitFieldNames ? '' : 'inetDiagTclass', fieldType: $pb.PbFieldType.OU3) ..aI(1501, _omitFieldNames ? '' : 'skMemInfoRmemAlloc', fieldType: $pb.PbFieldType.OU3) - ..aI(1502, _omitFieldNames ? '' : 'skMemInfoRcvBuf', + ..aI(1502, _omitFieldNames ? '' : 'skMemInfoRcvbuf', fieldType: $pb.PbFieldType.OU3) ..aI(1503, _omitFieldNames ? '' : 'skMemInfoWmemAlloc', fieldType: $pb.PbFieldType.OU3) - ..aI(1504, _omitFieldNames ? '' : 'skMemInfoSndBuf', + ..aI(1504, _omitFieldNames ? '' : 'skMemInfoSndbuf', fieldType: $pb.PbFieldType.OU3) ..aI(1505, _omitFieldNames ? '' : 'skMemInfoFwdAlloc', fieldType: $pb.PbFieldType.OU3) @@ -737,15 +741,15 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1509, _omitFieldNames ? '' : 'skMemInfoDrops', fieldType: $pb.PbFieldType.OU3) - ..aI(1600, _omitFieldNames ? '' : 'shutdownState', + ..aI(1600, _omitFieldNames ? '' : 'inetDiagShutdown', fieldType: $pb.PbFieldType.OU3) ..aI(1701, _omitFieldNames ? '' : 'vegasInfoEnabled', fieldType: $pb.PbFieldType.OU3) - ..aI(1702, _omitFieldNames ? '' : 'vegasInfoRttCnt', + ..aI(1702, _omitFieldNames ? '' : 'vegasInfoRttcnt', fieldType: $pb.PbFieldType.OU3) ..aI(1703, _omitFieldNames ? '' : 'vegasInfoRtt', fieldType: $pb.PbFieldType.OU3) - ..aI(1704, _omitFieldNames ? '' : 'vegasInfoMinRtt', + ..aI(1704, _omitFieldNames ? '' : 'vegasInfoMinrtt', fieldType: $pb.PbFieldType.OU3) ..aI(1801, _omitFieldNames ? '' : 'dctcpInfoEnabled', fieldType: $pb.PbFieldType.OU3) @@ -767,10 +771,12 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { fieldType: $pb.PbFieldType.OU3) ..aI(1905, _omitFieldNames ? '' : 'bbrInfoCwndGain', fieldType: $pb.PbFieldType.OU3) - ..aI(2001, _omitFieldNames ? '' : 'classId', fieldType: $pb.PbFieldType.OU3) - ..aI(2002, _omitFieldNames ? '' : 'sockOpt', fieldType: $pb.PbFieldType.OU3) + ..aI(2001, _omitFieldNames ? '' : 'inetDiagClassId', + fieldType: $pb.PbFieldType.OU3) + ..aI(2002, _omitFieldNames ? '' : 'inetDiagSockopt', + fieldType: $pb.PbFieldType.OU3) ..a<$fixnum.Int64>( - 2103, _omitFieldNames ? '' : 'cGroup', $pb.PbFieldType.OU6, + 2003, _omitFieldNames ? '' : 'inetDiagCgroupId', $pb.PbFieldType.OU6, defaultOrMaker: $fixnum.Int64.ZERO) ..hasRequiredFields = false; @@ -796,9 +802,10 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// ---- metadata: record format provenance (1-2) ---------------------------- /// Record format epoch. Stamped unconditionally into every record so consumers /// can route records to per-version tables and migrate/aggregate across them. - /// 0 = pre-versioning daemons (this field absent on the wire → proto3 zero - /// default), which acts as the "legacy" bucket. Bump the daemon-side constant - /// (XtcpFlatRecordSchemaVersion) whenever the format changes meaningfully. + /// 0 = pre-versioning daemons (this field absent on the wire -> proto3 zero + /// default), which acts as the "legacy" bucket. 1 = 2026-08/09 layout. + /// 2 = this layout (kernel-spelled payload names, enrichment regroup). Bump the + /// daemon-side constant (XtcpFlatRecordSchemaVersion) on any rename/renumber. @$pb.TagNumber(1) $core.int get schemaVersion => $_getIZ(0); @$pb.TagNumber(1) @@ -990,7 +997,8 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// Static per boot; captured once at startup (best-effort). Hosts are /// dual-homed, so there are two fixed uplink slots. All values repeat on every /// record and dictionary-compress to ~nothing. NIC info: sysfs + ethtool - /// ioctl. LLDP: lldpd control socket (/run/lldpd.socket). + /// ioctl (100-107, free 108-119). LLDP: lldpd control socket + /// (/run/lldpd.socket) (120-124, free 125-199). @$pb.TagNumber(100) $core.String get uplink1Ifname => $_getSZ(17); @$pb.TagNumber(100) @@ -1109,6 +1117,7 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { void clearUplink1LldpPortDescr() => $_clearField(124); /// ---- metadata: host network topology, uplink slot 2 (200s) --------------- + /// Same layout as slot 1 (NIC 200-207, LLDP 220-224). @$pb.TagNumber(200) $core.String get uplink2Ifname => $_getSZ(30); @$pb.TagNumber(200) @@ -1226,188 +1235,233 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { @$pb.TagNumber(224) void clearUplink2LldpPortDescr() => $_clearField(224); + /// ---- enrichment: socket-side (300-309) ----------------------------------- + /// Human name of the interface the socket is BOUND to, i.e. the resolved form + /// of inet_diag_msg_socket_interface (1009, the kernel idiag_if index) via the + /// namespace's RTM_GETLINK dump. Empty when idiag_if is 0 (the common case — + /// most sockets are not SO_BINDTODEVICE-bound) or the index is unknown. + @$pb.TagNumber(300) + $core.String get enrichSocketInterfaceName => $_getSZ(43); + @$pb.TagNumber(300) + set enrichSocketInterfaceName($core.String value) => $_setString(43, value); + @$pb.TagNumber(300) + $core.bool hasEnrichSocketInterfaceName() => $_has(43); + @$pb.TagNumber(300) + void clearEnrichSocketInterfaceName() => $_clearField(300); + + @$pb.TagNumber(310) + XtcpFlatRecord_Locality get enrichSocketDestLocality => $_getN(44); + @$pb.TagNumber(310) + set enrichSocketDestLocality(XtcpFlatRecord_Locality value) => + $_setField(310, value); + @$pb.TagNumber(310) + $core.bool hasEnrichSocketDestLocality() => $_has(44); + @$pb.TagNumber(310) + void clearEnrichSocketDestLocality() => $_clearField(310); + + /// The EGRESS interface for the destination, derived from the socket's own + /// namespace routing table: the Oif of the route the destination longest-prefix + /// matches (pkg/localnet). Unlike interface_name (1009/300) this is populated + /// even for unbound sockets — it is "which NIC does traffic to this dest leave + /// on". ifindex is the raw kernel index; ifname is it resolved via RTM_GETLINK. + /// 0 / empty when the locality enricher is disabled or no route matched. + @$pb.TagNumber(311) + $core.int get enrichSocketDestEgressIfindex => $_getIZ(45); + @$pb.TagNumber(311) + set enrichSocketDestEgressIfindex($core.int value) => + $_setUnsignedInt32(45, value); + @$pb.TagNumber(311) + $core.bool hasEnrichSocketDestEgressIfindex() => $_has(45); + @$pb.TagNumber(311) + void clearEnrichSocketDestEgressIfindex() => $_clearField(311); + + @$pb.TagNumber(312) + $core.String get enrichSocketDestEgressIfname => $_getSZ(46); + @$pb.TagNumber(312) + set enrichSocketDestEgressIfname($core.String value) => + $_setString(46, value); + @$pb.TagNumber(312) + $core.bool hasEnrichSocketDestEgressIfname() => $_has(46); + @$pb.TagNumber(312) + void clearEnrichSocketDestEgressIfname() => $_clearField(312); + + /// Populated by the opt-in ASN enricher (pkg/ipasn) only for REMOTE + /// destinations. 0 / empty when disabled or the destination IP is not in the + /// feed set. network_owner is a human name (e.g. "cloudflare", "aws"). + /// dest_next_hop_asn is the first-hop transit ASN toward dest; currently + /// always 0 (no BGP RIB source yet) — reserved for that feed. + @$pb.TagNumber(320) + $fixnum.Int64 get enrichSocketDestAsn => $_getI64(47); + @$pb.TagNumber(320) + set enrichSocketDestAsn($fixnum.Int64 value) => $_setInt64(47, value); + @$pb.TagNumber(320) + $core.bool hasEnrichSocketDestAsn() => $_has(47); + @$pb.TagNumber(320) + void clearEnrichSocketDestAsn() => $_clearField(320); + + @$pb.TagNumber(321) + $fixnum.Int64 get enrichSocketDestNextHopAsn => $_getI64(48); + @$pb.TagNumber(321) + set enrichSocketDestNextHopAsn($fixnum.Int64 value) => $_setInt64(48, value); + @$pb.TagNumber(321) + $core.bool hasEnrichSocketDestNextHopAsn() => $_has(48); + @$pb.TagNumber(321) + void clearEnrichSocketDestNextHopAsn() => $_clearField(321); + + @$pb.TagNumber(322) + $core.String get enrichSocketDestNetworkOwner => $_getSZ(49); + @$pb.TagNumber(322) + set enrichSocketDestNetworkOwner($core.String value) => + $_setString(49, value); + @$pb.TagNumber(322) + $core.bool hasEnrichSocketDestNetworkOwner() => $_has(49); + @$pb.TagNumber(322) + void clearEnrichSocketDestNetworkOwner() => $_clearField(322); + + /// ---- payload: struct inet_diag_msg (1000s) -------------------------------- + /// The fixed header of every SOCK_DIAG_BY_FAMILY reply (inet_diag.h). + /// Free: 1000, 1018-1099 (1011/1012/1018/1019 retired, see reserved). @$pb.TagNumber(1001) - $core.int get inetDiagMsgFamily => $_getIZ(43); + $core.int get inetDiagMsgFamily => $_getIZ(50); @$pb.TagNumber(1001) - set inetDiagMsgFamily($core.int value) => $_setUnsignedInt32(43, value); + set inetDiagMsgFamily($core.int value) => $_setUnsignedInt32(50, value); @$pb.TagNumber(1001) - $core.bool hasInetDiagMsgFamily() => $_has(43); + $core.bool hasInetDiagMsgFamily() => $_has(50); @$pb.TagNumber(1001) void clearInetDiagMsgFamily() => $_clearField(1001); @$pb.TagNumber(1002) - $core.int get inetDiagMsgState => $_getIZ(44); + $core.int get inetDiagMsgState => $_getIZ(51); @$pb.TagNumber(1002) - set inetDiagMsgState($core.int value) => $_setUnsignedInt32(44, value); + set inetDiagMsgState($core.int value) => $_setUnsignedInt32(51, value); @$pb.TagNumber(1002) - $core.bool hasInetDiagMsgState() => $_has(44); + $core.bool hasInetDiagMsgState() => $_has(51); @$pb.TagNumber(1002) void clearInetDiagMsgState() => $_clearField(1002); @$pb.TagNumber(1003) - $core.int get inetDiagMsgTimer => $_getIZ(45); + $core.int get inetDiagMsgTimer => $_getIZ(52); @$pb.TagNumber(1003) - set inetDiagMsgTimer($core.int value) => $_setUnsignedInt32(45, value); + set inetDiagMsgTimer($core.int value) => $_setUnsignedInt32(52, value); @$pb.TagNumber(1003) - $core.bool hasInetDiagMsgTimer() => $_has(45); + $core.bool hasInetDiagMsgTimer() => $_has(52); @$pb.TagNumber(1003) void clearInetDiagMsgTimer() => $_clearField(1003); @$pb.TagNumber(1004) - $core.int get inetDiagMsgRetrans => $_getIZ(46); + $core.int get inetDiagMsgRetrans => $_getIZ(53); @$pb.TagNumber(1004) - set inetDiagMsgRetrans($core.int value) => $_setUnsignedInt32(46, value); + set inetDiagMsgRetrans($core.int value) => $_setUnsignedInt32(53, value); @$pb.TagNumber(1004) - $core.bool hasInetDiagMsgRetrans() => $_has(46); + $core.bool hasInetDiagMsgRetrans() => $_has(53); @$pb.TagNumber(1004) void clearInetDiagMsgRetrans() => $_clearField(1004); @$pb.TagNumber(1005) - $core.int get inetDiagMsgSocketSourcePort => $_getIZ(47); + $core.int get inetDiagMsgSocketSourcePort => $_getIZ(54); @$pb.TagNumber(1005) set inetDiagMsgSocketSourcePort($core.int value) => - $_setUnsignedInt32(47, value); + $_setUnsignedInt32(54, value); @$pb.TagNumber(1005) - $core.bool hasInetDiagMsgSocketSourcePort() => $_has(47); + $core.bool hasInetDiagMsgSocketSourcePort() => $_has(54); @$pb.TagNumber(1005) void clearInetDiagMsgSocketSourcePort() => $_clearField(1005); @$pb.TagNumber(1006) - $core.int get inetDiagMsgSocketDestinationPort => $_getIZ(48); + $core.int get inetDiagMsgSocketDestinationPort => $_getIZ(55); @$pb.TagNumber(1006) set inetDiagMsgSocketDestinationPort($core.int value) => - $_setUnsignedInt32(48, value); + $_setUnsignedInt32(55, value); @$pb.TagNumber(1006) - $core.bool hasInetDiagMsgSocketDestinationPort() => $_has(48); + $core.bool hasInetDiagMsgSocketDestinationPort() => $_has(55); @$pb.TagNumber(1006) void clearInetDiagMsgSocketDestinationPort() => $_clearField(1006); @$pb.TagNumber(1007) - $core.List<$core.int> get inetDiagMsgSocketSource => $_getN(49); + $core.List<$core.int> get inetDiagMsgSocketSource => $_getN(56); @$pb.TagNumber(1007) set inetDiagMsgSocketSource($core.List<$core.int> value) => - $_setBytes(49, value); + $_setBytes(56, value); @$pb.TagNumber(1007) - $core.bool hasInetDiagMsgSocketSource() => $_has(49); + $core.bool hasInetDiagMsgSocketSource() => $_has(56); @$pb.TagNumber(1007) void clearInetDiagMsgSocketSource() => $_clearField(1007); @$pb.TagNumber(1008) - $core.List<$core.int> get inetDiagMsgSocketDestination => $_getN(50); + $core.List<$core.int> get inetDiagMsgSocketDestination => $_getN(57); @$pb.TagNumber(1008) set inetDiagMsgSocketDestination($core.List<$core.int> value) => - $_setBytes(50, value); + $_setBytes(57, value); @$pb.TagNumber(1008) - $core.bool hasInetDiagMsgSocketDestination() => $_has(50); + $core.bool hasInetDiagMsgSocketDestination() => $_has(57); @$pb.TagNumber(1008) void clearInetDiagMsgSocketDestination() => $_clearField(1008); @$pb.TagNumber(1009) - $core.int get inetDiagMsgSocketInterface => $_getIZ(51); + $core.int get inetDiagMsgSocketInterface => $_getIZ(58); @$pb.TagNumber(1009) set inetDiagMsgSocketInterface($core.int value) => - $_setUnsignedInt32(51, value); + $_setUnsignedInt32(58, value); @$pb.TagNumber(1009) - $core.bool hasInetDiagMsgSocketInterface() => $_has(51); + $core.bool hasInetDiagMsgSocketInterface() => $_has(58); @$pb.TagNumber(1009) void clearInetDiagMsgSocketInterface() => $_clearField(1009); @$pb.TagNumber(1010) - $fixnum.Int64 get inetDiagMsgSocketCookie => $_getI64(52); + $fixnum.Int64 get inetDiagMsgSocketCookie => $_getI64(59); @$pb.TagNumber(1010) - set inetDiagMsgSocketCookie($fixnum.Int64 value) => $_setInt64(52, value); + set inetDiagMsgSocketCookie($fixnum.Int64 value) => $_setInt64(59, value); @$pb.TagNumber(1010) - $core.bool hasInetDiagMsgSocketCookie() => $_has(52); + $core.bool hasInetDiagMsgSocketCookie() => $_has(59); @$pb.TagNumber(1010) void clearInetDiagMsgSocketCookie() => $_clearField(1010); - @$pb.TagNumber(1011) - $fixnum.Int64 get inetDiagMsgSocketDestAsn => $_getI64(53); - @$pb.TagNumber(1011) - set inetDiagMsgSocketDestAsn($fixnum.Int64 value) => $_setInt64(53, value); - @$pb.TagNumber(1011) - $core.bool hasInetDiagMsgSocketDestAsn() => $_has(53); - @$pb.TagNumber(1011) - void clearInetDiagMsgSocketDestAsn() => $_clearField(1011); - - @$pb.TagNumber(1012) - $fixnum.Int64 get inetDiagMsgSocketNextHopAsn => $_getI64(54); - @$pb.TagNumber(1012) - set inetDiagMsgSocketNextHopAsn($fixnum.Int64 value) => $_setInt64(54, value); - @$pb.TagNumber(1012) - $core.bool hasInetDiagMsgSocketNextHopAsn() => $_has(54); - @$pb.TagNumber(1012) - void clearInetDiagMsgSocketNextHopAsn() => $_clearField(1012); - @$pb.TagNumber(1013) - $core.int get inetDiagMsgExpires => $_getIZ(55); + $core.int get inetDiagMsgExpires => $_getIZ(60); @$pb.TagNumber(1013) - set inetDiagMsgExpires($core.int value) => $_setUnsignedInt32(55, value); + set inetDiagMsgExpires($core.int value) => $_setUnsignedInt32(60, value); @$pb.TagNumber(1013) - $core.bool hasInetDiagMsgExpires() => $_has(55); + $core.bool hasInetDiagMsgExpires() => $_has(60); @$pb.TagNumber(1013) void clearInetDiagMsgExpires() => $_clearField(1013); @$pb.TagNumber(1014) - $core.int get inetDiagMsgRqueue => $_getIZ(56); + $core.int get inetDiagMsgRqueue => $_getIZ(61); @$pb.TagNumber(1014) - set inetDiagMsgRqueue($core.int value) => $_setUnsignedInt32(56, value); + set inetDiagMsgRqueue($core.int value) => $_setUnsignedInt32(61, value); @$pb.TagNumber(1014) - $core.bool hasInetDiagMsgRqueue() => $_has(56); + $core.bool hasInetDiagMsgRqueue() => $_has(61); @$pb.TagNumber(1014) void clearInetDiagMsgRqueue() => $_clearField(1014); @$pb.TagNumber(1015) - $core.int get inetDiagMsgWqueue => $_getIZ(57); + $core.int get inetDiagMsgWqueue => $_getIZ(62); @$pb.TagNumber(1015) - set inetDiagMsgWqueue($core.int value) => $_setUnsignedInt32(57, value); + set inetDiagMsgWqueue($core.int value) => $_setUnsignedInt32(62, value); @$pb.TagNumber(1015) - $core.bool hasInetDiagMsgWqueue() => $_has(57); + $core.bool hasInetDiagMsgWqueue() => $_has(62); @$pb.TagNumber(1015) void clearInetDiagMsgWqueue() => $_clearField(1015); @$pb.TagNumber(1016) - $core.int get inetDiagMsgUid => $_getIZ(58); + $core.int get inetDiagMsgUid => $_getIZ(63); @$pb.TagNumber(1016) - set inetDiagMsgUid($core.int value) => $_setUnsignedInt32(58, value); + set inetDiagMsgUid($core.int value) => $_setUnsignedInt32(63, value); @$pb.TagNumber(1016) - $core.bool hasInetDiagMsgUid() => $_has(58); + $core.bool hasInetDiagMsgUid() => $_has(63); @$pb.TagNumber(1016) void clearInetDiagMsgUid() => $_clearField(1016); @$pb.TagNumber(1017) - $core.int get inetDiagMsgInode => $_getIZ(59); + $core.int get inetDiagMsgInode => $_getIZ(64); @$pb.TagNumber(1017) - set inetDiagMsgInode($core.int value) => $_setUnsignedInt32(59, value); + set inetDiagMsgInode($core.int value) => $_setUnsignedInt32(64, value); @$pb.TagNumber(1017) - $core.bool hasInetDiagMsgInode() => $_has(59); + $core.bool hasInetDiagMsgInode() => $_has(64); @$pb.TagNumber(1017) void clearInetDiagMsgInode() => $_clearField(1017); - /// Destination network owner (e.g. "cloudflare", "aws"), from the IP-range - /// feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the - /// opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the - /// destination IP is not in the feed set. - @$pb.TagNumber(1018) - $core.String get inetDiagMsgSocketDestNetworkOwner => $_getSZ(60); - @$pb.TagNumber(1018) - set inetDiagMsgSocketDestNetworkOwner($core.String value) => - $_setString(60, value); - @$pb.TagNumber(1018) - $core.bool hasInetDiagMsgSocketDestNetworkOwner() => $_has(60); - @$pb.TagNumber(1018) - void clearInetDiagMsgSocketDestNetworkOwner() => $_clearField(1018); - - @$pb.TagNumber(1019) - XtcpFlatRecord_Locality get inetDiagMsgSocketDestLocality => $_getN(61); - @$pb.TagNumber(1019) - set inetDiagMsgSocketDestLocality(XtcpFlatRecord_Locality value) => - $_setField(1019, value); - @$pb.TagNumber(1019) - $core.bool hasInetDiagMsgSocketDestLocality() => $_has(61); - @$pb.TagNumber(1019) - void clearInetDiagMsgSocketDestLocality() => $_clearField(1019); - + /// ---- payload: struct inet_diag_meminfo, INET_DIAG_MEMINFO 1 (1100s) ------- /// DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by /// default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), /// so these ship as 0 on current records. The same values live in sk_mem_info: @@ -1417,882 +1471,908 @@ class XtcpFlatRecord extends $pb.GeneratedMessage { /// mem_info_tmem == sk_mem_info_wmem_alloc (1503) /// Field numbers retained (never reused); enable with `-deserializers all`. /// (Not marked `[deprecated = true]` so the still-supported opt-in decode path - /// and tests don't trip staticcheck SA1019.) + /// and tests don't trip staticcheck SA1019.) Free: 1100, 1105-1199. @$pb.TagNumber(1101) - $core.int get memInfoRmem => $_getIZ(62); + $core.int get memInfoRmem => $_getIZ(65); @$pb.TagNumber(1101) - set memInfoRmem($core.int value) => $_setUnsignedInt32(62, value); + set memInfoRmem($core.int value) => $_setUnsignedInt32(65, value); @$pb.TagNumber(1101) - $core.bool hasMemInfoRmem() => $_has(62); + $core.bool hasMemInfoRmem() => $_has(65); @$pb.TagNumber(1101) void clearMemInfoRmem() => $_clearField(1101); @$pb.TagNumber(1102) - $core.int get memInfoWmem => $_getIZ(63); + $core.int get memInfoWmem => $_getIZ(66); @$pb.TagNumber(1102) - set memInfoWmem($core.int value) => $_setUnsignedInt32(63, value); + set memInfoWmem($core.int value) => $_setUnsignedInt32(66, value); @$pb.TagNumber(1102) - $core.bool hasMemInfoWmem() => $_has(63); + $core.bool hasMemInfoWmem() => $_has(66); @$pb.TagNumber(1102) void clearMemInfoWmem() => $_clearField(1102); @$pb.TagNumber(1103) - $core.int get memInfoFmem => $_getIZ(64); + $core.int get memInfoFmem => $_getIZ(67); @$pb.TagNumber(1103) - set memInfoFmem($core.int value) => $_setUnsignedInt32(64, value); + set memInfoFmem($core.int value) => $_setUnsignedInt32(67, value); @$pb.TagNumber(1103) - $core.bool hasMemInfoFmem() => $_has(64); + $core.bool hasMemInfoFmem() => $_has(67); @$pb.TagNumber(1103) void clearMemInfoFmem() => $_clearField(1103); @$pb.TagNumber(1104) - $core.int get memInfoTmem => $_getIZ(65); + $core.int get memInfoTmem => $_getIZ(68); @$pb.TagNumber(1104) - set memInfoTmem($core.int value) => $_setUnsignedInt32(65, value); + set memInfoTmem($core.int value) => $_setUnsignedInt32(68, value); @$pb.TagNumber(1104) - $core.bool hasMemInfoTmem() => $_has(65); + $core.bool hasMemInfoTmem() => $_has(68); @$pb.TagNumber(1104) void clearMemInfoTmem() => $_clearField(1104); + /// ---- payload: struct tcp_info, INET_DIAG_INFO 2 (1200s) ------------------- + /// Declared in struct order (tcp.h). The kernel appends members over time and + /// DeserializeTCPInfo (pkg/xtcpnl) accepts every historical struct size, so + /// members newer than the running kernel decode as 0. + /// Free: 1200, 1211-1214, 1277-1299. 1266-1276 are PRE-ASSIGNED (see below). @$pb.TagNumber(1201) - $core.int get tcpInfoState => $_getIZ(66); + $core.int get tcpInfoState => $_getIZ(69); @$pb.TagNumber(1201) - set tcpInfoState($core.int value) => $_setUnsignedInt32(66, value); + set tcpInfoState($core.int value) => $_setUnsignedInt32(69, value); @$pb.TagNumber(1201) - $core.bool hasTcpInfoState() => $_has(66); + $core.bool hasTcpInfoState() => $_has(69); @$pb.TagNumber(1201) void clearTcpInfoState() => $_clearField(1201); @$pb.TagNumber(1202) - $core.int get tcpInfoCaState => $_getIZ(67); + $core.int get tcpInfoCaState => $_getIZ(70); @$pb.TagNumber(1202) - set tcpInfoCaState($core.int value) => $_setUnsignedInt32(67, value); + set tcpInfoCaState($core.int value) => $_setUnsignedInt32(70, value); @$pb.TagNumber(1202) - $core.bool hasTcpInfoCaState() => $_has(67); + $core.bool hasTcpInfoCaState() => $_has(70); @$pb.TagNumber(1202) void clearTcpInfoCaState() => $_clearField(1202); @$pb.TagNumber(1203) - $core.int get tcpInfoRetransmits => $_getIZ(68); + $core.int get tcpInfoRetransmits => $_getIZ(71); @$pb.TagNumber(1203) - set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(68, value); + set tcpInfoRetransmits($core.int value) => $_setUnsignedInt32(71, value); @$pb.TagNumber(1203) - $core.bool hasTcpInfoRetransmits() => $_has(68); + $core.bool hasTcpInfoRetransmits() => $_has(71); @$pb.TagNumber(1203) void clearTcpInfoRetransmits() => $_clearField(1203); @$pb.TagNumber(1204) - $core.int get tcpInfoProbes => $_getIZ(69); + $core.int get tcpInfoProbes => $_getIZ(72); @$pb.TagNumber(1204) - set tcpInfoProbes($core.int value) => $_setUnsignedInt32(69, value); + set tcpInfoProbes($core.int value) => $_setUnsignedInt32(72, value); @$pb.TagNumber(1204) - $core.bool hasTcpInfoProbes() => $_has(69); + $core.bool hasTcpInfoProbes() => $_has(72); @$pb.TagNumber(1204) void clearTcpInfoProbes() => $_clearField(1204); @$pb.TagNumber(1205) - $core.int get tcpInfoBackoff => $_getIZ(70); + $core.int get tcpInfoBackoff => $_getIZ(73); @$pb.TagNumber(1205) - set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(70, value); + set tcpInfoBackoff($core.int value) => $_setUnsignedInt32(73, value); @$pb.TagNumber(1205) - $core.bool hasTcpInfoBackoff() => $_has(70); + $core.bool hasTcpInfoBackoff() => $_has(73); @$pb.TagNumber(1205) void clearTcpInfoBackoff() => $_clearField(1205); @$pb.TagNumber(1206) - $core.int get tcpInfoOptions => $_getIZ(71); + $core.int get tcpInfoOptions => $_getIZ(74); @$pb.TagNumber(1206) - set tcpInfoOptions($core.int value) => $_setUnsignedInt32(71, value); + set tcpInfoOptions($core.int value) => $_setUnsignedInt32(74, value); @$pb.TagNumber(1206) - $core.bool hasTcpInfoOptions() => $_has(71); + $core.bool hasTcpInfoOptions() => $_has(74); @$pb.TagNumber(1206) void clearTcpInfoOptions() => $_clearField(1206); - /// __u8 _snd_wscale : 4, _rcv_wscale : 4; - /// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; @$pb.TagNumber(1207) - $core.int get tcpInfoSendScale => $_getIZ(72); + $core.int get tcpInfoSndWscale => $_getIZ(75); @$pb.TagNumber(1207) - set tcpInfoSendScale($core.int value) => $_setUnsignedInt32(72, value); + set tcpInfoSndWscale($core.int value) => $_setUnsignedInt32(75, value); @$pb.TagNumber(1207) - $core.bool hasTcpInfoSendScale() => $_has(72); + $core.bool hasTcpInfoSndWscale() => $_has(75); @$pb.TagNumber(1207) - void clearTcpInfoSendScale() => $_clearField(1207); + void clearTcpInfoSndWscale() => $_clearField(1207); @$pb.TagNumber(1208) - $core.int get tcpInfoRcvScale => $_getIZ(73); + $core.int get tcpInfoRcvWscale => $_getIZ(76); @$pb.TagNumber(1208) - set tcpInfoRcvScale($core.int value) => $_setUnsignedInt32(73, value); + set tcpInfoRcvWscale($core.int value) => $_setUnsignedInt32(76, value); @$pb.TagNumber(1208) - $core.bool hasTcpInfoRcvScale() => $_has(73); + $core.bool hasTcpInfoRcvWscale() => $_has(76); @$pb.TagNumber(1208) - void clearTcpInfoRcvScale() => $_clearField(1208); + void clearTcpInfoRcvWscale() => $_clearField(1208); @$pb.TagNumber(1209) - $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(74); + $core.int get tcpInfoDeliveryRateAppLimited => $_getIZ(77); @$pb.TagNumber(1209) set tcpInfoDeliveryRateAppLimited($core.int value) => - $_setUnsignedInt32(74, value); + $_setUnsignedInt32(77, value); @$pb.TagNumber(1209) - $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(74); + $core.bool hasTcpInfoDeliveryRateAppLimited() => $_has(77); @$pb.TagNumber(1209) void clearTcpInfoDeliveryRateAppLimited() => $_clearField(1209); @$pb.TagNumber(1210) - $core.int get tcpInfoFastOpenClientFailed => $_getIZ(75); + $core.int get tcpInfoFastopenClientFail => $_getIZ(78); @$pb.TagNumber(1210) - set tcpInfoFastOpenClientFailed($core.int value) => - $_setUnsignedInt32(75, value); + set tcpInfoFastopenClientFail($core.int value) => + $_setUnsignedInt32(78, value); @$pb.TagNumber(1210) - $core.bool hasTcpInfoFastOpenClientFailed() => $_has(75); + $core.bool hasTcpInfoFastopenClientFail() => $_has(78); @$pb.TagNumber(1210) - void clearTcpInfoFastOpenClientFailed() => $_clearField(1210); + void clearTcpInfoFastopenClientFail() => $_clearField(1210); @$pb.TagNumber(1215) - $core.int get tcpInfoRto => $_getIZ(76); + $core.int get tcpInfoRto => $_getIZ(79); @$pb.TagNumber(1215) - set tcpInfoRto($core.int value) => $_setUnsignedInt32(76, value); + set tcpInfoRto($core.int value) => $_setUnsignedInt32(79, value); @$pb.TagNumber(1215) - $core.bool hasTcpInfoRto() => $_has(76); + $core.bool hasTcpInfoRto() => $_has(79); @$pb.TagNumber(1215) void clearTcpInfoRto() => $_clearField(1215); @$pb.TagNumber(1216) - $core.int get tcpInfoAto => $_getIZ(77); + $core.int get tcpInfoAto => $_getIZ(80); @$pb.TagNumber(1216) - set tcpInfoAto($core.int value) => $_setUnsignedInt32(77, value); + set tcpInfoAto($core.int value) => $_setUnsignedInt32(80, value); @$pb.TagNumber(1216) - $core.bool hasTcpInfoAto() => $_has(77); + $core.bool hasTcpInfoAto() => $_has(80); @$pb.TagNumber(1216) void clearTcpInfoAto() => $_clearField(1216); @$pb.TagNumber(1217) - $core.int get tcpInfoSndMss => $_getIZ(78); + $core.int get tcpInfoSndMss => $_getIZ(81); @$pb.TagNumber(1217) - set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(78, value); + set tcpInfoSndMss($core.int value) => $_setUnsignedInt32(81, value); @$pb.TagNumber(1217) - $core.bool hasTcpInfoSndMss() => $_has(78); + $core.bool hasTcpInfoSndMss() => $_has(81); @$pb.TagNumber(1217) void clearTcpInfoSndMss() => $_clearField(1217); @$pb.TagNumber(1218) - $core.int get tcpInfoRcvMss => $_getIZ(79); + $core.int get tcpInfoRcvMss => $_getIZ(82); @$pb.TagNumber(1218) - set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(79, value); + set tcpInfoRcvMss($core.int value) => $_setUnsignedInt32(82, value); @$pb.TagNumber(1218) - $core.bool hasTcpInfoRcvMss() => $_has(79); + $core.bool hasTcpInfoRcvMss() => $_has(82); @$pb.TagNumber(1218) void clearTcpInfoRcvMss() => $_clearField(1218); @$pb.TagNumber(1219) - $core.int get tcpInfoUnacked => $_getIZ(80); + $core.int get tcpInfoUnacked => $_getIZ(83); @$pb.TagNumber(1219) - set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(80, value); + set tcpInfoUnacked($core.int value) => $_setUnsignedInt32(83, value); @$pb.TagNumber(1219) - $core.bool hasTcpInfoUnacked() => $_has(80); + $core.bool hasTcpInfoUnacked() => $_has(83); @$pb.TagNumber(1219) void clearTcpInfoUnacked() => $_clearField(1219); @$pb.TagNumber(1220) - $core.int get tcpInfoSacked => $_getIZ(81); + $core.int get tcpInfoSacked => $_getIZ(84); @$pb.TagNumber(1220) - set tcpInfoSacked($core.int value) => $_setUnsignedInt32(81, value); + set tcpInfoSacked($core.int value) => $_setUnsignedInt32(84, value); @$pb.TagNumber(1220) - $core.bool hasTcpInfoSacked() => $_has(81); + $core.bool hasTcpInfoSacked() => $_has(84); @$pb.TagNumber(1220) void clearTcpInfoSacked() => $_clearField(1220); @$pb.TagNumber(1221) - $core.int get tcpInfoLost => $_getIZ(82); + $core.int get tcpInfoLost => $_getIZ(85); @$pb.TagNumber(1221) - set tcpInfoLost($core.int value) => $_setUnsignedInt32(82, value); + set tcpInfoLost($core.int value) => $_setUnsignedInt32(85, value); @$pb.TagNumber(1221) - $core.bool hasTcpInfoLost() => $_has(82); + $core.bool hasTcpInfoLost() => $_has(85); @$pb.TagNumber(1221) void clearTcpInfoLost() => $_clearField(1221); @$pb.TagNumber(1222) - $core.int get tcpInfoRetrans => $_getIZ(83); + $core.int get tcpInfoRetrans => $_getIZ(86); @$pb.TagNumber(1222) - set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(83, value); + set tcpInfoRetrans($core.int value) => $_setUnsignedInt32(86, value); @$pb.TagNumber(1222) - $core.bool hasTcpInfoRetrans() => $_has(83); + $core.bool hasTcpInfoRetrans() => $_has(86); @$pb.TagNumber(1222) void clearTcpInfoRetrans() => $_clearField(1222); @$pb.TagNumber(1223) - $core.int get tcpInfoFackets => $_getIZ(84); + $core.int get tcpInfoFackets => $_getIZ(87); @$pb.TagNumber(1223) - set tcpInfoFackets($core.int value) => $_setUnsignedInt32(84, value); + set tcpInfoFackets($core.int value) => $_setUnsignedInt32(87, value); @$pb.TagNumber(1223) - $core.bool hasTcpInfoFackets() => $_has(84); + $core.bool hasTcpInfoFackets() => $_has(87); @$pb.TagNumber(1223) void clearTcpInfoFackets() => $_clearField(1223); /// Times @$pb.TagNumber(1224) - $core.int get tcpInfoLastDataSent => $_getIZ(85); + $core.int get tcpInfoLastDataSent => $_getIZ(88); @$pb.TagNumber(1224) - set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(85, value); + set tcpInfoLastDataSent($core.int value) => $_setUnsignedInt32(88, value); @$pb.TagNumber(1224) - $core.bool hasTcpInfoLastDataSent() => $_has(85); + $core.bool hasTcpInfoLastDataSent() => $_has(88); @$pb.TagNumber(1224) void clearTcpInfoLastDataSent() => $_clearField(1224); @$pb.TagNumber(1225) - $core.int get tcpInfoLastAckSent => $_getIZ(86); + $core.int get tcpInfoLastAckSent => $_getIZ(89); @$pb.TagNumber(1225) - set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(86, value); + set tcpInfoLastAckSent($core.int value) => $_setUnsignedInt32(89, value); @$pb.TagNumber(1225) - $core.bool hasTcpInfoLastAckSent() => $_has(86); + $core.bool hasTcpInfoLastAckSent() => $_has(89); @$pb.TagNumber(1225) void clearTcpInfoLastAckSent() => $_clearField(1225); @$pb.TagNumber(1226) - $core.int get tcpInfoLastDataRecv => $_getIZ(87); + $core.int get tcpInfoLastDataRecv => $_getIZ(90); @$pb.TagNumber(1226) - set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(87, value); + set tcpInfoLastDataRecv($core.int value) => $_setUnsignedInt32(90, value); @$pb.TagNumber(1226) - $core.bool hasTcpInfoLastDataRecv() => $_has(87); + $core.bool hasTcpInfoLastDataRecv() => $_has(90); @$pb.TagNumber(1226) void clearTcpInfoLastDataRecv() => $_clearField(1226); @$pb.TagNumber(1227) - $core.int get tcpInfoLastAckRecv => $_getIZ(88); + $core.int get tcpInfoLastAckRecv => $_getIZ(91); @$pb.TagNumber(1227) - set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(88, value); + set tcpInfoLastAckRecv($core.int value) => $_setUnsignedInt32(91, value); @$pb.TagNumber(1227) - $core.bool hasTcpInfoLastAckRecv() => $_has(88); + $core.bool hasTcpInfoLastAckRecv() => $_has(91); @$pb.TagNumber(1227) void clearTcpInfoLastAckRecv() => $_clearField(1227); /// Metrics @$pb.TagNumber(1228) - $core.int get tcpInfoPmtu => $_getIZ(89); + $core.int get tcpInfoPmtu => $_getIZ(92); @$pb.TagNumber(1228) - set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(89, value); + set tcpInfoPmtu($core.int value) => $_setUnsignedInt32(92, value); @$pb.TagNumber(1228) - $core.bool hasTcpInfoPmtu() => $_has(89); + $core.bool hasTcpInfoPmtu() => $_has(92); @$pb.TagNumber(1228) void clearTcpInfoPmtu() => $_clearField(1228); @$pb.TagNumber(1229) - $core.int get tcpInfoRcvSsthresh => $_getIZ(90); + $core.int get tcpInfoRcvSsthresh => $_getIZ(93); @$pb.TagNumber(1229) - set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(90, value); + set tcpInfoRcvSsthresh($core.int value) => $_setUnsignedInt32(93, value); @$pb.TagNumber(1229) - $core.bool hasTcpInfoRcvSsthresh() => $_has(90); + $core.bool hasTcpInfoRcvSsthresh() => $_has(93); @$pb.TagNumber(1229) void clearTcpInfoRcvSsthresh() => $_clearField(1229); @$pb.TagNumber(1230) - $core.int get tcpInfoRtt => $_getIZ(91); + $core.int get tcpInfoRtt => $_getIZ(94); @$pb.TagNumber(1230) - set tcpInfoRtt($core.int value) => $_setUnsignedInt32(91, value); + set tcpInfoRtt($core.int value) => $_setUnsignedInt32(94, value); @$pb.TagNumber(1230) - $core.bool hasTcpInfoRtt() => $_has(91); + $core.bool hasTcpInfoRtt() => $_has(94); @$pb.TagNumber(1230) void clearTcpInfoRtt() => $_clearField(1230); @$pb.TagNumber(1231) - $core.int get tcpInfoRttVar => $_getIZ(92); + $core.int get tcpInfoRttvar => $_getIZ(95); @$pb.TagNumber(1231) - set tcpInfoRttVar($core.int value) => $_setUnsignedInt32(92, value); + set tcpInfoRttvar($core.int value) => $_setUnsignedInt32(95, value); @$pb.TagNumber(1231) - $core.bool hasTcpInfoRttVar() => $_has(92); + $core.bool hasTcpInfoRttvar() => $_has(95); @$pb.TagNumber(1231) - void clearTcpInfoRttVar() => $_clearField(1231); + void clearTcpInfoRttvar() => $_clearField(1231); @$pb.TagNumber(1232) - $core.int get tcpInfoSndSsthresh => $_getIZ(93); + $core.int get tcpInfoSndSsthresh => $_getIZ(96); @$pb.TagNumber(1232) - set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(93, value); + set tcpInfoSndSsthresh($core.int value) => $_setUnsignedInt32(96, value); @$pb.TagNumber(1232) - $core.bool hasTcpInfoSndSsthresh() => $_has(93); + $core.bool hasTcpInfoSndSsthresh() => $_has(96); @$pb.TagNumber(1232) void clearTcpInfoSndSsthresh() => $_clearField(1232); @$pb.TagNumber(1233) - $core.int get tcpInfoSndCwnd => $_getIZ(94); + $core.int get tcpInfoSndCwnd => $_getIZ(97); @$pb.TagNumber(1233) - set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(94, value); + set tcpInfoSndCwnd($core.int value) => $_setUnsignedInt32(97, value); @$pb.TagNumber(1233) - $core.bool hasTcpInfoSndCwnd() => $_has(94); + $core.bool hasTcpInfoSndCwnd() => $_has(97); @$pb.TagNumber(1233) void clearTcpInfoSndCwnd() => $_clearField(1233); @$pb.TagNumber(1234) - $core.int get tcpInfoAdvMss => $_getIZ(95); + $core.int get tcpInfoAdvmss => $_getIZ(98); @$pb.TagNumber(1234) - set tcpInfoAdvMss($core.int value) => $_setUnsignedInt32(95, value); + set tcpInfoAdvmss($core.int value) => $_setUnsignedInt32(98, value); @$pb.TagNumber(1234) - $core.bool hasTcpInfoAdvMss() => $_has(95); + $core.bool hasTcpInfoAdvmss() => $_has(98); @$pb.TagNumber(1234) - void clearTcpInfoAdvMss() => $_clearField(1234); + void clearTcpInfoAdvmss() => $_clearField(1234); @$pb.TagNumber(1235) - $core.int get tcpInfoReordering => $_getIZ(96); + $core.int get tcpInfoReordering => $_getIZ(99); @$pb.TagNumber(1235) - set tcpInfoReordering($core.int value) => $_setUnsignedInt32(96, value); + set tcpInfoReordering($core.int value) => $_setUnsignedInt32(99, value); @$pb.TagNumber(1235) - $core.bool hasTcpInfoReordering() => $_has(96); + $core.bool hasTcpInfoReordering() => $_has(99); @$pb.TagNumber(1235) void clearTcpInfoReordering() => $_clearField(1235); @$pb.TagNumber(1236) - $core.int get tcpInfoRcvRtt => $_getIZ(97); + $core.int get tcpInfoRcvRtt => $_getIZ(100); @$pb.TagNumber(1236) - set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(97, value); + set tcpInfoRcvRtt($core.int value) => $_setUnsignedInt32(100, value); @$pb.TagNumber(1236) - $core.bool hasTcpInfoRcvRtt() => $_has(97); + $core.bool hasTcpInfoRcvRtt() => $_has(100); @$pb.TagNumber(1236) void clearTcpInfoRcvRtt() => $_clearField(1236); @$pb.TagNumber(1237) - $core.int get tcpInfoRcvSpace => $_getIZ(98); + $core.int get tcpInfoRcvSpace => $_getIZ(101); @$pb.TagNumber(1237) - set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(98, value); + set tcpInfoRcvSpace($core.int value) => $_setUnsignedInt32(101, value); @$pb.TagNumber(1237) - $core.bool hasTcpInfoRcvSpace() => $_has(98); + $core.bool hasTcpInfoRcvSpace() => $_has(101); @$pb.TagNumber(1237) void clearTcpInfoRcvSpace() => $_clearField(1237); @$pb.TagNumber(1238) - $core.int get tcpInfoTotalRetrans => $_getIZ(99); + $core.int get tcpInfoTotalRetrans => $_getIZ(102); @$pb.TagNumber(1238) - set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(99, value); + set tcpInfoTotalRetrans($core.int value) => $_setUnsignedInt32(102, value); @$pb.TagNumber(1238) - $core.bool hasTcpInfoTotalRetrans() => $_has(99); + $core.bool hasTcpInfoTotalRetrans() => $_has(102); @$pb.TagNumber(1238) void clearTcpInfoTotalRetrans() => $_clearField(1238); @$pb.TagNumber(1239) - $fixnum.Int64 get tcpInfoPacingRate => $_getI64(100); + $fixnum.Int64 get tcpInfoPacingRate => $_getI64(103); @$pb.TagNumber(1239) - set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(100, value); + set tcpInfoPacingRate($fixnum.Int64 value) => $_setInt64(103, value); @$pb.TagNumber(1239) - $core.bool hasTcpInfoPacingRate() => $_has(100); + $core.bool hasTcpInfoPacingRate() => $_has(103); @$pb.TagNumber(1239) void clearTcpInfoPacingRate() => $_clearField(1239); @$pb.TagNumber(1240) - $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(101); + $fixnum.Int64 get tcpInfoMaxPacingRate => $_getI64(104); @$pb.TagNumber(1240) - set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(101, value); + set tcpInfoMaxPacingRate($fixnum.Int64 value) => $_setInt64(104, value); @$pb.TagNumber(1240) - $core.bool hasTcpInfoMaxPacingRate() => $_has(101); + $core.bool hasTcpInfoMaxPacingRate() => $_has(104); @$pb.TagNumber(1240) void clearTcpInfoMaxPacingRate() => $_clearField(1240); @$pb.TagNumber(1241) - $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(102); + $fixnum.Int64 get tcpInfoBytesAcked => $_getI64(105); @$pb.TagNumber(1241) - set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(102, value); + set tcpInfoBytesAcked($fixnum.Int64 value) => $_setInt64(105, value); @$pb.TagNumber(1241) - $core.bool hasTcpInfoBytesAcked() => $_has(102); + $core.bool hasTcpInfoBytesAcked() => $_has(105); @$pb.TagNumber(1241) void clearTcpInfoBytesAcked() => $_clearField(1241); @$pb.TagNumber(1242) - $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(103); + $fixnum.Int64 get tcpInfoBytesReceived => $_getI64(106); @$pb.TagNumber(1242) - set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(103, value); + set tcpInfoBytesReceived($fixnum.Int64 value) => $_setInt64(106, value); @$pb.TagNumber(1242) - $core.bool hasTcpInfoBytesReceived() => $_has(103); + $core.bool hasTcpInfoBytesReceived() => $_has(106); @$pb.TagNumber(1242) void clearTcpInfoBytesReceived() => $_clearField(1242); @$pb.TagNumber(1243) - $core.int get tcpInfoSegsOut => $_getIZ(104); + $core.int get tcpInfoSegsOut => $_getIZ(107); @$pb.TagNumber(1243) - set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(104, value); + set tcpInfoSegsOut($core.int value) => $_setUnsignedInt32(107, value); @$pb.TagNumber(1243) - $core.bool hasTcpInfoSegsOut() => $_has(104); + $core.bool hasTcpInfoSegsOut() => $_has(107); @$pb.TagNumber(1243) void clearTcpInfoSegsOut() => $_clearField(1243); @$pb.TagNumber(1244) - $core.int get tcpInfoSegsIn => $_getIZ(105); + $core.int get tcpInfoSegsIn => $_getIZ(108); @$pb.TagNumber(1244) - set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(105, value); + set tcpInfoSegsIn($core.int value) => $_setUnsignedInt32(108, value); @$pb.TagNumber(1244) - $core.bool hasTcpInfoSegsIn() => $_has(105); + $core.bool hasTcpInfoSegsIn() => $_has(108); @$pb.TagNumber(1244) void clearTcpInfoSegsIn() => $_clearField(1244); @$pb.TagNumber(1245) - $core.int get tcpInfoNotSentBytes => $_getIZ(106); + $core.int get tcpInfoNotsentBytes => $_getIZ(109); @$pb.TagNumber(1245) - set tcpInfoNotSentBytes($core.int value) => $_setUnsignedInt32(106, value); + set tcpInfoNotsentBytes($core.int value) => $_setUnsignedInt32(109, value); @$pb.TagNumber(1245) - $core.bool hasTcpInfoNotSentBytes() => $_has(106); + $core.bool hasTcpInfoNotsentBytes() => $_has(109); @$pb.TagNumber(1245) - void clearTcpInfoNotSentBytes() => $_clearField(1245); + void clearTcpInfoNotsentBytes() => $_clearField(1245); @$pb.TagNumber(1246) - $core.int get tcpInfoMinRtt => $_getIZ(107); + $core.int get tcpInfoMinRtt => $_getIZ(110); @$pb.TagNumber(1246) - set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(107, value); + set tcpInfoMinRtt($core.int value) => $_setUnsignedInt32(110, value); @$pb.TagNumber(1246) - $core.bool hasTcpInfoMinRtt() => $_has(107); + $core.bool hasTcpInfoMinRtt() => $_has(110); @$pb.TagNumber(1246) void clearTcpInfoMinRtt() => $_clearField(1246); @$pb.TagNumber(1247) - $core.int get tcpInfoDataSegsIn => $_getIZ(108); + $core.int get tcpInfoDataSegsIn => $_getIZ(111); @$pb.TagNumber(1247) - set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(108, value); + set tcpInfoDataSegsIn($core.int value) => $_setUnsignedInt32(111, value); @$pb.TagNumber(1247) - $core.bool hasTcpInfoDataSegsIn() => $_has(108); + $core.bool hasTcpInfoDataSegsIn() => $_has(111); @$pb.TagNumber(1247) void clearTcpInfoDataSegsIn() => $_clearField(1247); @$pb.TagNumber(1248) - $core.int get tcpInfoDataSegsOut => $_getIZ(109); + $core.int get tcpInfoDataSegsOut => $_getIZ(112); @$pb.TagNumber(1248) - set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(109, value); + set tcpInfoDataSegsOut($core.int value) => $_setUnsignedInt32(112, value); @$pb.TagNumber(1248) - $core.bool hasTcpInfoDataSegsOut() => $_has(109); + $core.bool hasTcpInfoDataSegsOut() => $_has(112); @$pb.TagNumber(1248) void clearTcpInfoDataSegsOut() => $_clearField(1248); @$pb.TagNumber(1249) - $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(110); + $fixnum.Int64 get tcpInfoDeliveryRate => $_getI64(113); @$pb.TagNumber(1249) - set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(110, value); + set tcpInfoDeliveryRate($fixnum.Int64 value) => $_setInt64(113, value); @$pb.TagNumber(1249) - $core.bool hasTcpInfoDeliveryRate() => $_has(110); + $core.bool hasTcpInfoDeliveryRate() => $_has(113); @$pb.TagNumber(1249) void clearTcpInfoDeliveryRate() => $_clearField(1249); @$pb.TagNumber(1250) - $fixnum.Int64 get tcpInfoBusyTime => $_getI64(111); + $fixnum.Int64 get tcpInfoBusyTime => $_getI64(114); @$pb.TagNumber(1250) - set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(111, value); + set tcpInfoBusyTime($fixnum.Int64 value) => $_setInt64(114, value); @$pb.TagNumber(1250) - $core.bool hasTcpInfoBusyTime() => $_has(111); + $core.bool hasTcpInfoBusyTime() => $_has(114); @$pb.TagNumber(1250) void clearTcpInfoBusyTime() => $_clearField(1250); @$pb.TagNumber(1251) - $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(112); + $fixnum.Int64 get tcpInfoRwndLimited => $_getI64(115); @$pb.TagNumber(1251) - set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(112, value); + set tcpInfoRwndLimited($fixnum.Int64 value) => $_setInt64(115, value); @$pb.TagNumber(1251) - $core.bool hasTcpInfoRwndLimited() => $_has(112); + $core.bool hasTcpInfoRwndLimited() => $_has(115); @$pb.TagNumber(1251) void clearTcpInfoRwndLimited() => $_clearField(1251); @$pb.TagNumber(1252) - $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(113); + $fixnum.Int64 get tcpInfoSndbufLimited => $_getI64(116); @$pb.TagNumber(1252) - set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(113, value); + set tcpInfoSndbufLimited($fixnum.Int64 value) => $_setInt64(116, value); @$pb.TagNumber(1252) - $core.bool hasTcpInfoSndbufLimited() => $_has(113); + $core.bool hasTcpInfoSndbufLimited() => $_has(116); @$pb.TagNumber(1252) void clearTcpInfoSndbufLimited() => $_clearField(1252); + /// 4.15 kernel tcp_info ends here (192 bytes); 4.19+ below @$pb.TagNumber(1253) - $core.int get tcpInfoDelivered => $_getIZ(114); + $core.int get tcpInfoDelivered => $_getIZ(117); @$pb.TagNumber(1253) - set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(114, value); + set tcpInfoDelivered($core.int value) => $_setUnsignedInt32(117, value); @$pb.TagNumber(1253) - $core.bool hasTcpInfoDelivered() => $_has(114); + $core.bool hasTcpInfoDelivered() => $_has(117); @$pb.TagNumber(1253) void clearTcpInfoDelivered() => $_clearField(1253); @$pb.TagNumber(1254) - $core.int get tcpInfoDeliveredCe => $_getIZ(115); + $core.int get tcpInfoDeliveredCe => $_getIZ(118); @$pb.TagNumber(1254) - set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(115, value); + set tcpInfoDeliveredCe($core.int value) => $_setUnsignedInt32(118, value); @$pb.TagNumber(1254) - $core.bool hasTcpInfoDeliveredCe() => $_has(115); + $core.bool hasTcpInfoDeliveredCe() => $_has(118); @$pb.TagNumber(1254) void clearTcpInfoDeliveredCe() => $_clearField(1254); /// https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB @$pb.TagNumber(1255) - $fixnum.Int64 get tcpInfoBytesSent => $_getI64(116); + $fixnum.Int64 get tcpInfoBytesSent => $_getI64(119); @$pb.TagNumber(1255) - set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(116, value); + set tcpInfoBytesSent($fixnum.Int64 value) => $_setInt64(119, value); @$pb.TagNumber(1255) - $core.bool hasTcpInfoBytesSent() => $_has(116); + $core.bool hasTcpInfoBytesSent() => $_has(119); @$pb.TagNumber(1255) void clearTcpInfoBytesSent() => $_clearField(1255); @$pb.TagNumber(1256) - $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(117); + $fixnum.Int64 get tcpInfoBytesRetrans => $_getI64(120); @$pb.TagNumber(1256) - set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(117, value); + set tcpInfoBytesRetrans($fixnum.Int64 value) => $_setInt64(120, value); @$pb.TagNumber(1256) - $core.bool hasTcpInfoBytesRetrans() => $_has(117); + $core.bool hasTcpInfoBytesRetrans() => $_has(120); @$pb.TagNumber(1256) void clearTcpInfoBytesRetrans() => $_clearField(1256); @$pb.TagNumber(1257) - $core.int get tcpInfoDsackDups => $_getIZ(118); + $core.int get tcpInfoDsackDups => $_getIZ(121); @$pb.TagNumber(1257) - set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(118, value); + set tcpInfoDsackDups($core.int value) => $_setUnsignedInt32(121, value); @$pb.TagNumber(1257) - $core.bool hasTcpInfoDsackDups() => $_has(118); + $core.bool hasTcpInfoDsackDups() => $_has(121); @$pb.TagNumber(1257) void clearTcpInfoDsackDups() => $_clearField(1257); @$pb.TagNumber(1258) - $core.int get tcpInfoReordSeen => $_getIZ(119); + $core.int get tcpInfoReordSeen => $_getIZ(122); @$pb.TagNumber(1258) - set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(119, value); + set tcpInfoReordSeen($core.int value) => $_setUnsignedInt32(122, value); @$pb.TagNumber(1258) - $core.bool hasTcpInfoReordSeen() => $_has(119); + $core.bool hasTcpInfoReordSeen() => $_has(122); @$pb.TagNumber(1258) void clearTcpInfoReordSeen() => $_clearField(1258); @$pb.TagNumber(1259) - $core.int get tcpInfoRcvOoopack => $_getIZ(120); + $core.int get tcpInfoRcvOoopack => $_getIZ(123); @$pb.TagNumber(1259) - set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(120, value); + set tcpInfoRcvOoopack($core.int value) => $_setUnsignedInt32(123, value); @$pb.TagNumber(1259) - $core.bool hasTcpInfoRcvOoopack() => $_has(120); + $core.bool hasTcpInfoRcvOoopack() => $_has(123); @$pb.TagNumber(1259) void clearTcpInfoRcvOoopack() => $_clearField(1259); @$pb.TagNumber(1260) - $core.int get tcpInfoSndWnd => $_getIZ(121); + $core.int get tcpInfoSndWnd => $_getIZ(124); @$pb.TagNumber(1260) - set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(121, value); + set tcpInfoSndWnd($core.int value) => $_setUnsignedInt32(124, value); @$pb.TagNumber(1260) - $core.bool hasTcpInfoSndWnd() => $_has(121); + $core.bool hasTcpInfoSndWnd() => $_has(124); @$pb.TagNumber(1260) void clearTcpInfoSndWnd() => $_clearField(1260); @$pb.TagNumber(1261) - $core.int get tcpInfoRcvWnd => $_getIZ(122); + $core.int get tcpInfoRcvWnd => $_getIZ(125); @$pb.TagNumber(1261) - set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(122, value); + set tcpInfoRcvWnd($core.int value) => $_setUnsignedInt32(125, value); @$pb.TagNumber(1261) - $core.bool hasTcpInfoRcvWnd() => $_has(122); + $core.bool hasTcpInfoRcvWnd() => $_has(125); @$pb.TagNumber(1261) void clearTcpInfoRcvWnd() => $_clearField(1261); @$pb.TagNumber(1262) - $core.int get tcpInfoRehash => $_getIZ(123); + $core.int get tcpInfoRehash => $_getIZ(126); @$pb.TagNumber(1262) - set tcpInfoRehash($core.int value) => $_setUnsignedInt32(123, value); + set tcpInfoRehash($core.int value) => $_setUnsignedInt32(126, value); @$pb.TagNumber(1262) - $core.bool hasTcpInfoRehash() => $_has(123); + $core.bool hasTcpInfoRehash() => $_has(126); @$pb.TagNumber(1262) void clearTcpInfoRehash() => $_clearField(1262); @$pb.TagNumber(1263) - $core.int get tcpInfoTotalRto => $_getIZ(124); + $core.int get tcpInfoTotalRto => $_getIZ(127); @$pb.TagNumber(1263) - set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(124, value); + set tcpInfoTotalRto($core.int value) => $_setUnsignedInt32(127, value); @$pb.TagNumber(1263) - $core.bool hasTcpInfoTotalRto() => $_has(124); + $core.bool hasTcpInfoTotalRto() => $_has(127); @$pb.TagNumber(1263) void clearTcpInfoTotalRto() => $_clearField(1263); @$pb.TagNumber(1264) - $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(125); + $core.int get tcpInfoTotalRtoRecoveries => $_getIZ(128); @$pb.TagNumber(1264) set tcpInfoTotalRtoRecoveries($core.int value) => - $_setUnsignedInt32(125, value); + $_setUnsignedInt32(128, value); @$pb.TagNumber(1264) - $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(125); + $core.bool hasTcpInfoTotalRtoRecoveries() => $_has(128); @$pb.TagNumber(1264) void clearTcpInfoTotalRtoRecoveries() => $_clearField(1264); @$pb.TagNumber(1265) - $core.int get tcpInfoTotalRtoTime => $_getIZ(126); + $core.int get tcpInfoTotalRtoTime => $_getIZ(129); @$pb.TagNumber(1265) - set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(126, value); + set tcpInfoTotalRtoTime($core.int value) => $_setUnsignedInt32(129, value); @$pb.TagNumber(1265) - $core.bool hasTcpInfoTotalRtoTime() => $_has(126); + $core.bool hasTcpInfoTotalRtoTime() => $_has(129); @$pb.TagNumber(1265) void clearTcpInfoTotalRtoTime() => $_clearField(1265); - /// Please note it's recommended to use the enum for efficency, but keeping the string - /// just in case we need to quickly put a different algorithm in without updating the enum. - /// Obviously it's optional, so it low cost. + /// ---- payload: INET_DIAG_CONG 4 (1300s) ------------------------------------ + /// The kernel emits the congestion-control module name as a NUL-terminated + /// string (nla_put_string(skb, INET_DIAG_CONG, ca_ops->name), inet_diag.c). + /// It's recommended to use the enum for efficiency, but the string is kept so + /// an algorithm the enum does not know yet is still visible. Free: 1302-1399. @$pb.TagNumber(1300) - $core.String get congestionAlgorithmString => $_getSZ(127); + $core.String get inetDiagCong => $_getSZ(130); @$pb.TagNumber(1300) - set congestionAlgorithmString($core.String value) => $_setString(127, value); + set inetDiagCong($core.String value) => $_setString(130, value); @$pb.TagNumber(1300) - $core.bool hasCongestionAlgorithmString() => $_has(127); + $core.bool hasInetDiagCong() => $_has(130); @$pb.TagNumber(1300) - void clearCongestionAlgorithmString() => $_clearField(1300); + void clearInetDiagCong() => $_clearField(1300); @$pb.TagNumber(1301) - XtcpFlatRecord_CongestionAlgorithm get congestionAlgorithmEnum => $_getN(128); + XtcpFlatRecord_CongestionAlgorithm get inetDiagCongEnum => $_getN(131); @$pb.TagNumber(1301) - set congestionAlgorithmEnum(XtcpFlatRecord_CongestionAlgorithm value) => + set inetDiagCongEnum(XtcpFlatRecord_CongestionAlgorithm value) => $_setField(1301, value); @$pb.TagNumber(1301) - $core.bool hasCongestionAlgorithmEnum() => $_has(128); + $core.bool hasInetDiagCongEnum() => $_has(131); @$pb.TagNumber(1301) - void clearCongestionAlgorithmEnum() => $_clearField(1301); + void clearInetDiagCongEnum() => $_clearField(1301); + /// ---- payload: INET_DIAG_TOS 5 / INET_DIAG_TCLASS 6 (1400s) ---------------- + /// Free: 1400, 1403-1499. @$pb.TagNumber(1401) - $core.int get typeOfService => $_getIZ(129); + $core.int get inetDiagTos => $_getIZ(132); @$pb.TagNumber(1401) - set typeOfService($core.int value) => $_setUnsignedInt32(129, value); + set inetDiagTos($core.int value) => $_setUnsignedInt32(132, value); @$pb.TagNumber(1401) - $core.bool hasTypeOfService() => $_has(129); + $core.bool hasInetDiagTos() => $_has(132); @$pb.TagNumber(1401) - void clearTypeOfService() => $_clearField(1401); + void clearInetDiagTos() => $_clearField(1401); @$pb.TagNumber(1402) - $core.int get trafficClass => $_getIZ(130); + $core.int get inetDiagTclass => $_getIZ(133); @$pb.TagNumber(1402) - set trafficClass($core.int value) => $_setUnsignedInt32(130, value); + set inetDiagTclass($core.int value) => $_setUnsignedInt32(133, value); @$pb.TagNumber(1402) - $core.bool hasTrafficClass() => $_has(130); + $core.bool hasInetDiagTclass() => $_has(133); @$pb.TagNumber(1402) - void clearTrafficClass() => $_clearField(1402); + void clearInetDiagTclass() => $_clearField(1402); + /// ---- payload: SK_MEMINFO_*, INET_DIAG_SKMEMINFO 7 (1500s) ----------------- + /// __u32 mem[SK_MEMINFO_VARS] filled by sk_get_meminfo (net/core/sock.c), + /// indexed by enum sock_diag.h SK_MEMINFO_*. Free: 1500, 1510-1599. @$pb.TagNumber(1501) - $core.int get skMemInfoRmemAlloc => $_getIZ(131); + $core.int get skMemInfoRmemAlloc => $_getIZ(134); @$pb.TagNumber(1501) - set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(131, value); + set skMemInfoRmemAlloc($core.int value) => $_setUnsignedInt32(134, value); @$pb.TagNumber(1501) - $core.bool hasSkMemInfoRmemAlloc() => $_has(131); + $core.bool hasSkMemInfoRmemAlloc() => $_has(134); @$pb.TagNumber(1501) void clearSkMemInfoRmemAlloc() => $_clearField(1501); @$pb.TagNumber(1502) - $core.int get skMemInfoRcvBuf => $_getIZ(132); + $core.int get skMemInfoRcvbuf => $_getIZ(135); @$pb.TagNumber(1502) - set skMemInfoRcvBuf($core.int value) => $_setUnsignedInt32(132, value); + set skMemInfoRcvbuf($core.int value) => $_setUnsignedInt32(135, value); @$pb.TagNumber(1502) - $core.bool hasSkMemInfoRcvBuf() => $_has(132); + $core.bool hasSkMemInfoRcvbuf() => $_has(135); @$pb.TagNumber(1502) - void clearSkMemInfoRcvBuf() => $_clearField(1502); + void clearSkMemInfoRcvbuf() => $_clearField(1502); @$pb.TagNumber(1503) - $core.int get skMemInfoWmemAlloc => $_getIZ(133); + $core.int get skMemInfoWmemAlloc => $_getIZ(136); @$pb.TagNumber(1503) - set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(133, value); + set skMemInfoWmemAlloc($core.int value) => $_setUnsignedInt32(136, value); @$pb.TagNumber(1503) - $core.bool hasSkMemInfoWmemAlloc() => $_has(133); + $core.bool hasSkMemInfoWmemAlloc() => $_has(136); @$pb.TagNumber(1503) void clearSkMemInfoWmemAlloc() => $_clearField(1503); @$pb.TagNumber(1504) - $core.int get skMemInfoSndBuf => $_getIZ(134); + $core.int get skMemInfoSndbuf => $_getIZ(137); @$pb.TagNumber(1504) - set skMemInfoSndBuf($core.int value) => $_setUnsignedInt32(134, value); + set skMemInfoSndbuf($core.int value) => $_setUnsignedInt32(137, value); @$pb.TagNumber(1504) - $core.bool hasSkMemInfoSndBuf() => $_has(134); + $core.bool hasSkMemInfoSndbuf() => $_has(137); @$pb.TagNumber(1504) - void clearSkMemInfoSndBuf() => $_clearField(1504); + void clearSkMemInfoSndbuf() => $_clearField(1504); @$pb.TagNumber(1505) - $core.int get skMemInfoFwdAlloc => $_getIZ(135); + $core.int get skMemInfoFwdAlloc => $_getIZ(138); @$pb.TagNumber(1505) - set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(135, value); + set skMemInfoFwdAlloc($core.int value) => $_setUnsignedInt32(138, value); @$pb.TagNumber(1505) - $core.bool hasSkMemInfoFwdAlloc() => $_has(135); + $core.bool hasSkMemInfoFwdAlloc() => $_has(138); @$pb.TagNumber(1505) void clearSkMemInfoFwdAlloc() => $_clearField(1505); @$pb.TagNumber(1506) - $core.int get skMemInfoWmemQueued => $_getIZ(136); + $core.int get skMemInfoWmemQueued => $_getIZ(139); @$pb.TagNumber(1506) - set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(136, value); + set skMemInfoWmemQueued($core.int value) => $_setUnsignedInt32(139, value); @$pb.TagNumber(1506) - $core.bool hasSkMemInfoWmemQueued() => $_has(136); + $core.bool hasSkMemInfoWmemQueued() => $_has(139); @$pb.TagNumber(1506) void clearSkMemInfoWmemQueued() => $_clearField(1506); @$pb.TagNumber(1507) - $core.int get skMemInfoOptmem => $_getIZ(137); + $core.int get skMemInfoOptmem => $_getIZ(140); @$pb.TagNumber(1507) - set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(137, value); + set skMemInfoOptmem($core.int value) => $_setUnsignedInt32(140, value); @$pb.TagNumber(1507) - $core.bool hasSkMemInfoOptmem() => $_has(137); + $core.bool hasSkMemInfoOptmem() => $_has(140); @$pb.TagNumber(1507) void clearSkMemInfoOptmem() => $_clearField(1507); @$pb.TagNumber(1508) - $core.int get skMemInfoBacklog => $_getIZ(138); + $core.int get skMemInfoBacklog => $_getIZ(141); @$pb.TagNumber(1508) - set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(138, value); + set skMemInfoBacklog($core.int value) => $_setUnsignedInt32(141, value); @$pb.TagNumber(1508) - $core.bool hasSkMemInfoBacklog() => $_has(138); + $core.bool hasSkMemInfoBacklog() => $_has(141); @$pb.TagNumber(1508) void clearSkMemInfoBacklog() => $_clearField(1508); @$pb.TagNumber(1509) - $core.int get skMemInfoDrops => $_getIZ(139); + $core.int get skMemInfoDrops => $_getIZ(142); @$pb.TagNumber(1509) - set skMemInfoDrops($core.int value) => $_setUnsignedInt32(139, value); + set skMemInfoDrops($core.int value) => $_setUnsignedInt32(142, value); @$pb.TagNumber(1509) - $core.bool hasSkMemInfoDrops() => $_has(139); + $core.bool hasSkMemInfoDrops() => $_has(142); @$pb.TagNumber(1509) void clearSkMemInfoDrops() => $_clearField(1509); + /// ---- payload: INET_DIAG_SHUTDOWN 8 (1600s) -------------------------------- + /// Free: 1601-1699. @$pb.TagNumber(1600) - $core.int get shutdownState => $_getIZ(140); + $core.int get inetDiagShutdown => $_getIZ(143); @$pb.TagNumber(1600) - set shutdownState($core.int value) => $_setUnsignedInt32(140, value); + set inetDiagShutdown($core.int value) => $_setUnsignedInt32(143, value); @$pb.TagNumber(1600) - $core.bool hasShutdownState() => $_has(140); + $core.bool hasInetDiagShutdown() => $_has(143); @$pb.TagNumber(1600) - void clearShutdownState() => $_clearField(1600); + void clearInetDiagShutdown() => $_clearField(1600); + /// ---- payload: struct tcpvegas_info, INET_DIAG_VEGASINFO 3 (1700s) --------- + /// Only present when the socket's CC module is vegas (tcp_vegas.c + /// tcp_vegas_get_info). Free: 1700, 1705-1799. @$pb.TagNumber(1701) - $core.int get vegasInfoEnabled => $_getIZ(141); + $core.int get vegasInfoEnabled => $_getIZ(144); @$pb.TagNumber(1701) - set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(141, value); + set vegasInfoEnabled($core.int value) => $_setUnsignedInt32(144, value); @$pb.TagNumber(1701) - $core.bool hasVegasInfoEnabled() => $_has(141); + $core.bool hasVegasInfoEnabled() => $_has(144); @$pb.TagNumber(1701) void clearVegasInfoEnabled() => $_clearField(1701); @$pb.TagNumber(1702) - $core.int get vegasInfoRttCnt => $_getIZ(142); + $core.int get vegasInfoRttcnt => $_getIZ(145); @$pb.TagNumber(1702) - set vegasInfoRttCnt($core.int value) => $_setUnsignedInt32(142, value); + set vegasInfoRttcnt($core.int value) => $_setUnsignedInt32(145, value); @$pb.TagNumber(1702) - $core.bool hasVegasInfoRttCnt() => $_has(142); + $core.bool hasVegasInfoRttcnt() => $_has(145); @$pb.TagNumber(1702) - void clearVegasInfoRttCnt() => $_clearField(1702); + void clearVegasInfoRttcnt() => $_clearField(1702); @$pb.TagNumber(1703) - $core.int get vegasInfoRtt => $_getIZ(143); + $core.int get vegasInfoRtt => $_getIZ(146); @$pb.TagNumber(1703) - set vegasInfoRtt($core.int value) => $_setUnsignedInt32(143, value); + set vegasInfoRtt($core.int value) => $_setUnsignedInt32(146, value); @$pb.TagNumber(1703) - $core.bool hasVegasInfoRtt() => $_has(143); + $core.bool hasVegasInfoRtt() => $_has(146); @$pb.TagNumber(1703) void clearVegasInfoRtt() => $_clearField(1703); @$pb.TagNumber(1704) - $core.int get vegasInfoMinRtt => $_getIZ(144); + $core.int get vegasInfoMinrtt => $_getIZ(147); @$pb.TagNumber(1704) - set vegasInfoMinRtt($core.int value) => $_setUnsignedInt32(144, value); + set vegasInfoMinrtt($core.int value) => $_setUnsignedInt32(147, value); @$pb.TagNumber(1704) - $core.bool hasVegasInfoMinRtt() => $_has(144); + $core.bool hasVegasInfoMinrtt() => $_has(147); @$pb.TagNumber(1704) - void clearVegasInfoMinRtt() => $_clearField(1704); + void clearVegasInfoMinrtt() => $_clearField(1704); + /// ---- payload: struct tcp_dctcp_info, INET_DIAG_DCTCPINFO 9 (1800s) -------- + /// Only present when the socket's CC module is dctcp (tcp_dctcp.c + /// dctcp_get_info); requested via the VEGASINFO bit. Free: 1800, 1806-1899. @$pb.TagNumber(1801) - $core.int get dctcpInfoEnabled => $_getIZ(145); + $core.int get dctcpInfoEnabled => $_getIZ(148); @$pb.TagNumber(1801) - set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(145, value); + set dctcpInfoEnabled($core.int value) => $_setUnsignedInt32(148, value); @$pb.TagNumber(1801) - $core.bool hasDctcpInfoEnabled() => $_has(145); + $core.bool hasDctcpInfoEnabled() => $_has(148); @$pb.TagNumber(1801) void clearDctcpInfoEnabled() => $_clearField(1801); @$pb.TagNumber(1802) - $core.int get dctcpInfoCeState => $_getIZ(146); + $core.int get dctcpInfoCeState => $_getIZ(149); @$pb.TagNumber(1802) - set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(146, value); + set dctcpInfoCeState($core.int value) => $_setUnsignedInt32(149, value); @$pb.TagNumber(1802) - $core.bool hasDctcpInfoCeState() => $_has(146); + $core.bool hasDctcpInfoCeState() => $_has(149); @$pb.TagNumber(1802) void clearDctcpInfoCeState() => $_clearField(1802); @$pb.TagNumber(1803) - $core.int get dctcpInfoAlpha => $_getIZ(147); + $core.int get dctcpInfoAlpha => $_getIZ(150); @$pb.TagNumber(1803) - set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(147, value); + set dctcpInfoAlpha($core.int value) => $_setUnsignedInt32(150, value); @$pb.TagNumber(1803) - $core.bool hasDctcpInfoAlpha() => $_has(147); + $core.bool hasDctcpInfoAlpha() => $_has(150); @$pb.TagNumber(1803) void clearDctcpInfoAlpha() => $_clearField(1803); @$pb.TagNumber(1804) - $core.int get dctcpInfoAbEcn => $_getIZ(148); + $core.int get dctcpInfoAbEcn => $_getIZ(151); @$pb.TagNumber(1804) - set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(148, value); + set dctcpInfoAbEcn($core.int value) => $_setUnsignedInt32(151, value); @$pb.TagNumber(1804) - $core.bool hasDctcpInfoAbEcn() => $_has(148); + $core.bool hasDctcpInfoAbEcn() => $_has(151); @$pb.TagNumber(1804) void clearDctcpInfoAbEcn() => $_clearField(1804); @$pb.TagNumber(1805) - $core.int get dctcpInfoAbTot => $_getIZ(149); + $core.int get dctcpInfoAbTot => $_getIZ(152); @$pb.TagNumber(1805) - set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(149, value); + set dctcpInfoAbTot($core.int value) => $_setUnsignedInt32(152, value); @$pb.TagNumber(1805) - $core.bool hasDctcpInfoAbTot() => $_has(149); + $core.bool hasDctcpInfoAbTot() => $_has(152); @$pb.TagNumber(1805) void clearDctcpInfoAbTot() => $_clearField(1805); + /// ---- payload: struct tcp_bbr_info, INET_DIAG_BBRINFO 16 (1900s) ----------- + /// Only present when the socket's CC module is bbr (tcp_bbr.c bbr_get_info); + /// requested via the VEGASINFO bit. Free: 1900, 1906-1999. @$pb.TagNumber(1901) - $core.int get bbrInfoBwLo => $_getIZ(150); + $core.int get bbrInfoBwLo => $_getIZ(153); @$pb.TagNumber(1901) - set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(150, value); + set bbrInfoBwLo($core.int value) => $_setUnsignedInt32(153, value); @$pb.TagNumber(1901) - $core.bool hasBbrInfoBwLo() => $_has(150); + $core.bool hasBbrInfoBwLo() => $_has(153); @$pb.TagNumber(1901) void clearBbrInfoBwLo() => $_clearField(1901); @$pb.TagNumber(1902) - $core.int get bbrInfoBwHi => $_getIZ(151); + $core.int get bbrInfoBwHi => $_getIZ(154); @$pb.TagNumber(1902) - set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(151, value); + set bbrInfoBwHi($core.int value) => $_setUnsignedInt32(154, value); @$pb.TagNumber(1902) - $core.bool hasBbrInfoBwHi() => $_has(151); + $core.bool hasBbrInfoBwHi() => $_has(154); @$pb.TagNumber(1902) void clearBbrInfoBwHi() => $_clearField(1902); @$pb.TagNumber(1903) - $core.int get bbrInfoMinRtt => $_getIZ(152); + $core.int get bbrInfoMinRtt => $_getIZ(155); @$pb.TagNumber(1903) - set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(152, value); + set bbrInfoMinRtt($core.int value) => $_setUnsignedInt32(155, value); @$pb.TagNumber(1903) - $core.bool hasBbrInfoMinRtt() => $_has(152); + $core.bool hasBbrInfoMinRtt() => $_has(155); @$pb.TagNumber(1903) void clearBbrInfoMinRtt() => $_clearField(1903); @$pb.TagNumber(1904) - $core.int get bbrInfoPacingGain => $_getIZ(153); + $core.int get bbrInfoPacingGain => $_getIZ(156); @$pb.TagNumber(1904) - set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(153, value); + set bbrInfoPacingGain($core.int value) => $_setUnsignedInt32(156, value); @$pb.TagNumber(1904) - $core.bool hasBbrInfoPacingGain() => $_has(153); + $core.bool hasBbrInfoPacingGain() => $_has(156); @$pb.TagNumber(1904) void clearBbrInfoPacingGain() => $_clearField(1904); @$pb.TagNumber(1905) - $core.int get bbrInfoCwndGain => $_getIZ(154); + $core.int get bbrInfoCwndGain => $_getIZ(157); @$pb.TagNumber(1905) - set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(154, value); + set bbrInfoCwndGain($core.int value) => $_setUnsignedInt32(157, value); @$pb.TagNumber(1905) - $core.bool hasBbrInfoCwndGain() => $_has(154); + $core.bool hasBbrInfoCwndGain() => $_has(157); @$pb.TagNumber(1905) void clearBbrInfoCwndGain() => $_clearField(1905); + /// ---- payload: socket classification attributes (2000s) -------------------- + /// INET_DIAG_CLASS_ID 17, INET_DIAG_SOCKOPT 22, INET_DIAG_CGROUP_ID 21 — the + /// per-socket scalars inet_diag_msg_attrs_fill emits after the CC extensions. + /// Free: 2000, 2004-2099. Next free block: 2100. @$pb.TagNumber(2001) - $core.int get classId => $_getIZ(155); + $core.int get inetDiagClassId => $_getIZ(158); @$pb.TagNumber(2001) - set classId($core.int value) => $_setUnsignedInt32(155, value); + set inetDiagClassId($core.int value) => $_setUnsignedInt32(158, value); @$pb.TagNumber(2001) - $core.bool hasClassId() => $_has(155); + $core.bool hasInetDiagClassId() => $_has(158); @$pb.TagNumber(2001) - void clearClassId() => $_clearField(2001); + void clearInetDiagClassId() => $_clearField(2001); @$pb.TagNumber(2002) - $core.int get sockOpt => $_getIZ(156); + $core.int get inetDiagSockopt => $_getIZ(159); @$pb.TagNumber(2002) - set sockOpt($core.int value) => $_setUnsignedInt32(156, value); + set inetDiagSockopt($core.int value) => $_setUnsignedInt32(159, value); @$pb.TagNumber(2002) - $core.bool hasSockOpt() => $_has(156); + $core.bool hasInetDiagSockopt() => $_has(159); @$pb.TagNumber(2002) - void clearSockOpt() => $_clearField(2002); - - @$pb.TagNumber(2103) - $fixnum.Int64 get cGroup => $_getI64(157); - @$pb.TagNumber(2103) - set cGroup($fixnum.Int64 value) => $_setInt64(157, value); - @$pb.TagNumber(2103) - $core.bool hasCGroup() => $_has(157); - @$pb.TagNumber(2103) - void clearCGroup() => $_clearField(2103); + void clearInetDiagSockopt() => $_clearField(2002); + + @$pb.TagNumber(2003) + $fixnum.Int64 get inetDiagCgroupId => $_getI64(160); + @$pb.TagNumber(2003) + set inetDiagCgroupId($fixnum.Int64 value) => $_setInt64(160, value); + @$pb.TagNumber(2003) + $core.bool hasInetDiagCgroupId() => $_has(160); + @$pb.TagNumber(2003) + void clearInetDiagCgroupId() => $_clearField(2003); } class FlatRecordsRequest extends $pb.GeneratedMessage { diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart index de264cb..7ecffaa 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbenum.dart @@ -14,13 +14,13 @@ import 'dart:core' as $core; import 'package:protobuf/protobuf.dart' as $pb; +/// ---- enrichment: destination-side (310-349) ------------------------------ /// Destination endpoint locality, classified from the socket's own network /// namespace's local addresses + routing table (discovered via rtnetlink, -/// see pkg/localnet). Populated by the opt-in locality enricher BEFORE the -/// ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, -/// so dest_asn (1011) / dest_network_owner (1018) stay empty for them. -/// UNSPECIFIED when locality enrichment is disabled or the namespace has no -/// snapshot yet. +/// see pkg/localnet). Computed BEFORE the ASN lookup: SELF and LOCAL_SUBNET +/// destinations never reach the ASN feed, so enrich_socket_dest_asn (320) / +/// enrich_socket_dest_network_owner (322) stay empty for them. UNSPECIFIED +/// when locality enrichment is disabled or the namespace has no snapshot yet. class XtcpFlatRecord_Locality extends $pb.ProtobufEnum { static const XtcpFlatRecord_Locality LOCALITY_UNSPECIFIED = XtcpFlatRecord_Locality._( diff --git a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart index 9d24bc7..cf2718e 100644 --- a/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart +++ b/gen/dart/xtcp_flat_record/v1/xtcp_flat_record.pbjson.dart @@ -232,6 +232,56 @@ const XtcpFlatRecord$json = { '5': 9, '10': 'uplink2LldpPortDescr' }, + { + '1': 'enrich_socket_interface_name', + '3': 300, + '4': 1, + '5': 9, + '10': 'enrichSocketInterfaceName' + }, + { + '1': 'enrich_socket_dest_locality', + '3': 310, + '4': 1, + '5': 14, + '6': '.xtcp_flat_record.v1.XtcpFlatRecord.Locality', + '10': 'enrichSocketDestLocality' + }, + { + '1': 'enrich_socket_dest_egress_ifindex', + '3': 311, + '4': 1, + '5': 13, + '10': 'enrichSocketDestEgressIfindex' + }, + { + '1': 'enrich_socket_dest_egress_ifname', + '3': 312, + '4': 1, + '5': 9, + '10': 'enrichSocketDestEgressIfname' + }, + { + '1': 'enrich_socket_dest_asn', + '3': 320, + '4': 1, + '5': 4, + '10': 'enrichSocketDestAsn' + }, + { + '1': 'enrich_socket_dest_next_hop_asn', + '3': 321, + '4': 1, + '5': 4, + '10': 'enrichSocketDestNextHopAsn' + }, + { + '1': 'enrich_socket_dest_network_owner', + '3': 322, + '4': 1, + '5': 9, + '10': 'enrichSocketDestNetworkOwner' + }, { '1': 'inet_diag_msg_family', '3': 1001, @@ -302,20 +352,6 @@ const XtcpFlatRecord$json = { '5': 4, '10': 'inetDiagMsgSocketCookie' }, - { - '1': 'inet_diag_msg_socket_dest_asn', - '3': 1011, - '4': 1, - '5': 4, - '10': 'inetDiagMsgSocketDestAsn' - }, - { - '1': 'inet_diag_msg_socket_next_hop_asn', - '3': 1012, - '4': 1, - '5': 4, - '10': 'inetDiagMsgSocketNextHopAsn' - }, { '1': 'inet_diag_msg_expires', '3': 1013, @@ -351,21 +387,6 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'inetDiagMsgInode' }, - { - '1': 'inet_diag_msg_socket_dest_network_owner', - '3': 1018, - '4': 1, - '5': 9, - '10': 'inetDiagMsgSocketDestNetworkOwner' - }, - { - '1': 'inet_diag_msg_socket_dest_locality', - '3': 1019, - '4': 1, - '5': 14, - '6': '.xtcp_flat_record.v1.XtcpFlatRecord.Locality', - '10': 'inetDiagMsgSocketDestLocality' - }, {'1': 'mem_info_rmem', '3': 1101, '4': 1, '5': 13, '10': 'memInfoRmem'}, {'1': 'mem_info_wmem', '3': 1102, '4': 1, '5': 13, '10': 'memInfoWmem'}, {'1': 'mem_info_fmem', '3': 1103, '4': 1, '5': 13, '10': 'memInfoFmem'}, @@ -401,18 +422,18 @@ const XtcpFlatRecord$json = { '10': 'tcpInfoOptions' }, { - '1': 'tcp_info_send_scale', + '1': 'tcp_info_snd_wscale', '3': 1207, '4': 1, '5': 13, - '10': 'tcpInfoSendScale' + '10': 'tcpInfoSndWscale' }, { - '1': 'tcp_info_rcv_scale', + '1': 'tcp_info_rcv_wscale', '3': 1208, '4': 1, '5': 13, - '10': 'tcpInfoRcvScale' + '10': 'tcpInfoRcvWscale' }, { '1': 'tcp_info_delivery_rate_app_limited', @@ -422,11 +443,11 @@ const XtcpFlatRecord$json = { '10': 'tcpInfoDeliveryRateAppLimited' }, { - '1': 'tcp_info_fast_open_client_failed', + '1': 'tcp_info_fastopen_client_fail', '3': 1210, '4': 1, '5': 13, - '10': 'tcpInfoFastOpenClientFailed' + '10': 'tcpInfoFastopenClientFail' }, {'1': 'tcp_info_rto', '3': 1215, '4': 1, '5': 13, '10': 'tcpInfoRto'}, {'1': 'tcp_info_ato', '3': 1216, '4': 1, '5': 13, '10': 'tcpInfoAto'}, @@ -504,13 +525,7 @@ const XtcpFlatRecord$json = { '10': 'tcpInfoRcvSsthresh' }, {'1': 'tcp_info_rtt', '3': 1230, '4': 1, '5': 13, '10': 'tcpInfoRtt'}, - { - '1': 'tcp_info_rtt_var', - '3': 1231, - '4': 1, - '5': 13, - '10': 'tcpInfoRttVar' - }, + {'1': 'tcp_info_rttvar', '3': 1231, '4': 1, '5': 13, '10': 'tcpInfoRttvar'}, { '1': 'tcp_info_snd_ssthresh', '3': 1232, @@ -525,13 +540,7 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'tcpInfoSndCwnd' }, - { - '1': 'tcp_info_adv_mss', - '3': 1234, - '4': 1, - '5': 13, - '10': 'tcpInfoAdvMss' - }, + {'1': 'tcp_info_advmss', '3': 1234, '4': 1, '5': 13, '10': 'tcpInfoAdvmss'}, { '1': 'tcp_info_reordering', '3': 1235, @@ -603,11 +612,11 @@ const XtcpFlatRecord$json = { '10': 'tcpInfoSegsIn' }, { - '1': 'tcp_info_not_sent_bytes', + '1': 'tcp_info_notsent_bytes', '3': 1245, '4': 1, '5': 13, - '10': 'tcpInfoNotSentBytes' + '10': 'tcpInfoNotsentBytes' }, { '1': 'tcp_info_min_rtt', @@ -743,23 +752,23 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'tcpInfoTotalRtoTime' }, + {'1': 'inet_diag_cong', '3': 1300, '4': 1, '5': 9, '10': 'inetDiagCong'}, { - '1': 'congestion_algorithm_string', - '3': 1300, - '4': 1, - '5': 9, - '10': 'congestionAlgorithmString' - }, - { - '1': 'congestion_algorithm_enum', + '1': 'inet_diag_cong_enum', '3': 1301, '4': 1, '5': 14, '6': '.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm', - '10': 'congestionAlgorithmEnum' + '10': 'inetDiagCongEnum' + }, + {'1': 'inet_diag_tos', '3': 1401, '4': 1, '5': 13, '10': 'inetDiagTos'}, + { + '1': 'inet_diag_tclass', + '3': 1402, + '4': 1, + '5': 13, + '10': 'inetDiagTclass' }, - {'1': 'type_of_service', '3': 1401, '4': 1, '5': 13, '10': 'typeOfService'}, - {'1': 'traffic_class', '3': 1402, '4': 1, '5': 13, '10': 'trafficClass'}, { '1': 'sk_mem_info_rmem_alloc', '3': 1501, @@ -768,11 +777,11 @@ const XtcpFlatRecord$json = { '10': 'skMemInfoRmemAlloc' }, { - '1': 'sk_mem_info_rcv_buf', + '1': 'sk_mem_info_rcvbuf', '3': 1502, '4': 1, '5': 13, - '10': 'skMemInfoRcvBuf' + '10': 'skMemInfoRcvbuf' }, { '1': 'sk_mem_info_wmem_alloc', @@ -782,11 +791,11 @@ const XtcpFlatRecord$json = { '10': 'skMemInfoWmemAlloc' }, { - '1': 'sk_mem_info_snd_buf', + '1': 'sk_mem_info_sndbuf', '3': 1504, '4': 1, '5': 13, - '10': 'skMemInfoSndBuf' + '10': 'skMemInfoSndbuf' }, { '1': 'sk_mem_info_fwd_alloc', @@ -823,7 +832,13 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'skMemInfoDrops' }, - {'1': 'shutdown_state', '3': 1600, '4': 1, '5': 13, '10': 'shutdownState'}, + { + '1': 'inet_diag_shutdown', + '3': 1600, + '4': 1, + '5': 13, + '10': 'inetDiagShutdown' + }, { '1': 'vegas_info_enabled', '3': 1701, @@ -832,19 +847,19 @@ const XtcpFlatRecord$json = { '10': 'vegasInfoEnabled' }, { - '1': 'vegas_info_rtt_cnt', + '1': 'vegas_info_rttcnt', '3': 1702, '4': 1, '5': 13, - '10': 'vegasInfoRttCnt' + '10': 'vegasInfoRttcnt' }, {'1': 'vegas_info_rtt', '3': 1703, '4': 1, '5': 13, '10': 'vegasInfoRtt'}, { - '1': 'vegas_info_min_rtt', + '1': 'vegas_info_minrtt', '3': 1704, '4': 1, '5': 13, - '10': 'vegasInfoMinRtt' + '10': 'vegasInfoMinrtt' }, { '1': 'dctcp_info_enabled', @@ -904,11 +919,63 @@ const XtcpFlatRecord$json = { '5': 13, '10': 'bbrInfoCwndGain' }, - {'1': 'class_id', '3': 2001, '4': 1, '5': 13, '10': 'classId'}, - {'1': 'sock_opt', '3': 2002, '4': 1, '5': 13, '10': 'sockOpt'}, - {'1': 'c_group', '3': 2103, '4': 1, '5': 4, '10': 'cGroup'}, + { + '1': 'inet_diag_class_id', + '3': 2001, + '4': 1, + '5': 13, + '10': 'inetDiagClassId' + }, + { + '1': 'inet_diag_sockopt', + '3': 2002, + '4': 1, + '5': 13, + '10': 'inetDiagSockopt' + }, + { + '1': 'inet_diag_cgroup_id', + '3': 2003, + '4': 1, + '5': 4, + '10': 'inetDiagCgroupId' + }, ], '4': [XtcpFlatRecord_Locality$json, XtcpFlatRecord_CongestionAlgorithm$json], + '9': [ + {'1': 301, '2': 302}, + {'1': 302, '2': 303}, + {'1': 1011, '2': 1012}, + {'1': 1012, '2': 1013}, + {'1': 1018, '2': 1019}, + {'1': 1019, '2': 1020}, + {'1': 2103, '2': 2104}, + ], + '10': [ + 'inet_diag_msg_socket_dest_asn', + 'inet_diag_msg_socket_next_hop_asn', + 'inet_diag_msg_socket_dest_network_owner', + 'inet_diag_msg_socket_dest_locality', + 'enrich_socket_next_hop_asn', + 'tcp_info_send_scale', + 'tcp_info_rcv_scale', + 'tcp_info_fast_open_client_failed', + 'tcp_info_rtt_var', + 'tcp_info_adv_mss', + 'tcp_info_not_sent_bytes', + 'sk_mem_info_rcv_buf', + 'sk_mem_info_snd_buf', + 'vegas_info_rtt_cnt', + 'vegas_info_min_rtt', + 'congestion_algorithm_string', + 'congestion_algorithm_enum', + 'type_of_service', + 'traffic_class', + 'shutdown_state', + 'class_id', + 'sock_opt', + 'c_group' + ], }; @$core.Deprecated('Use xtcpFlatRecordDescriptor instead') @@ -973,117 +1040,131 @@ final $typed_data.Uint8List xtcpFlatRecordDescriptor = $convert.base64Decode( 'JMbGRwQ2hhc3Npc0lkEjAKFHVwbGluazJfbGxkcF9tZ210X2lwGN4BIAEoCVIRdXBsaW5rMkxs' 'ZHBNZ210SXASMAoUdXBsaW5rMl9sbGRwX3BvcnRfaWQY3wEgASgJUhF1cGxpbmsyTGxkcFBvcn' 'RJZBI2Chd1cGxpbmsyX2xsZHBfcG9ydF9kZXNjchjgASABKAlSFHVwbGluazJMbGRwUG9ydERl' - 'c2NyEjAKFGluZXRfZGlhZ19tc2dfZmFtaWx5GOkHIAEoDVIRaW5ldERpYWdNc2dGYW1pbHkSLg' - 'oTaW5ldF9kaWFnX21zZ19zdGF0ZRjqByABKA1SEGluZXREaWFnTXNnU3RhdGUSLgoTaW5ldF9k' - 'aWFnX21zZ190aW1lchjrByABKA1SEGluZXREaWFnTXNnVGltZXISMgoVaW5ldF9kaWFnX21zZ1' - '9yZXRyYW5zGOwHIAEoDVISaW5ldERpYWdNc2dSZXRyYW5zEkYKIGluZXRfZGlhZ19tc2dfc29j' - 'a2V0X3NvdXJjZV9wb3J0GO0HIAEoDVIbaW5ldERpYWdNc2dTb2NrZXRTb3VyY2VQb3J0ElAKJW' - 'luZXRfZGlhZ19tc2dfc29ja2V0X2Rlc3RpbmF0aW9uX3BvcnQY7gcgASgNUiBpbmV0RGlhZ01z' - 'Z1NvY2tldERlc3RpbmF0aW9uUG9ydBI9ChtpbmV0X2RpYWdfbXNnX3NvY2tldF9zb3VyY2UY7w' - 'cgASgMUhdpbmV0RGlhZ01zZ1NvY2tldFNvdXJjZRJHCiBpbmV0X2RpYWdfbXNnX3NvY2tldF9k' - 'ZXN0aW5hdGlvbhjwByABKAxSHGluZXREaWFnTXNnU29ja2V0RGVzdGluYXRpb24SQwoeaW5ldF' - '9kaWFnX21zZ19zb2NrZXRfaW50ZXJmYWNlGPEHIAEoDVIaaW5ldERpYWdNc2dTb2NrZXRJbnRl' - 'cmZhY2USPQobaW5ldF9kaWFnX21zZ19zb2NrZXRfY29va2llGPIHIAEoBFIXaW5ldERpYWdNc2' - 'dTb2NrZXRDb29raWUSQAodaW5ldF9kaWFnX21zZ19zb2NrZXRfZGVzdF9hc24Y8wcgASgEUhhp' - 'bmV0RGlhZ01zZ1NvY2tldERlc3RBc24SRwohaW5ldF9kaWFnX21zZ19zb2NrZXRfbmV4dF9ob3' - 'BfYXNuGPQHIAEoBFIbaW5ldERpYWdNc2dTb2NrZXROZXh0SG9wQXNuEjIKFWluZXRfZGlhZ19t' - 'c2dfZXhwaXJlcxj1ByABKA1SEmluZXREaWFnTXNnRXhwaXJlcxIwChRpbmV0X2RpYWdfbXNnX3' - 'JxdWV1ZRj2ByABKA1SEWluZXREaWFnTXNnUnF1ZXVlEjAKFGluZXRfZGlhZ19tc2dfd3F1ZXVl' - 'GPcHIAEoDVIRaW5ldERpYWdNc2dXcXVldWUSKgoRaW5ldF9kaWFnX21zZ191aWQY+AcgASgNUg' - '5pbmV0RGlhZ01zZ1VpZBIuChNpbmV0X2RpYWdfbXNnX2lub2RlGPkHIAEoDVIQaW5ldERpYWdN' - 'c2dJbm9kZRJTCidpbmV0X2RpYWdfbXNnX3NvY2tldF9kZXN0X25ldHdvcmtfb3duZXIY+gcgAS' - 'gJUiFpbmV0RGlhZ01zZ1NvY2tldERlc3ROZXR3b3JrT3duZXISeAoiaW5ldF9kaWFnX21zZ19z' - 'b2NrZXRfZGVzdF9sb2NhbGl0eRj7ByABKA4yLC54dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbG' - 'F0UmVjb3JkLkxvY2FsaXR5Uh1pbmV0RGlhZ01zZ1NvY2tldERlc3RMb2NhbGl0eRIjCg1tZW1f' - 'aW5mb19ybWVtGM0IIAEoDVILbWVtSW5mb1JtZW0SIwoNbWVtX2luZm9fd21lbRjOCCABKA1SC2' - '1lbUluZm9XbWVtEiMKDW1lbV9pbmZvX2ZtZW0YzwggASgNUgttZW1JbmZvRm1lbRIjCg1tZW1f' - 'aW5mb190bWVtGNAIIAEoDVILbWVtSW5mb1RtZW0SJQoOdGNwX2luZm9fc3RhdGUYsQkgASgNUg' - 'x0Y3BJbmZvU3RhdGUSKgoRdGNwX2luZm9fY2Ffc3RhdGUYsgkgASgNUg50Y3BJbmZvQ2FTdGF0' - 'ZRIxChR0Y3BfaW5mb19yZXRyYW5zbWl0cxizCSABKA1SEnRjcEluZm9SZXRyYW5zbWl0cxInCg' - '90Y3BfaW5mb19wcm9iZXMYtAkgASgNUg10Y3BJbmZvUHJvYmVzEikKEHRjcF9pbmZvX2JhY2tv' - 'ZmYYtQkgASgNUg50Y3BJbmZvQmFja29mZhIpChB0Y3BfaW5mb19vcHRpb25zGLYJIAEoDVIOdG' - 'NwSW5mb09wdGlvbnMSLgoTdGNwX2luZm9fc2VuZF9zY2FsZRi3CSABKA1SEHRjcEluZm9TZW5k' - 'U2NhbGUSLAoSdGNwX2luZm9fcmN2X3NjYWxlGLgJIAEoDVIPdGNwSW5mb1JjdlNjYWxlEkoKIn' - 'RjcF9pbmZvX2RlbGl2ZXJ5X3JhdGVfYXBwX2xpbWl0ZWQYuQkgASgNUh10Y3BJbmZvRGVsaXZl' - 'cnlSYXRlQXBwTGltaXRlZBJGCiB0Y3BfaW5mb19mYXN0X29wZW5fY2xpZW50X2ZhaWxlZBi6CS' - 'ABKA1SG3RjcEluZm9GYXN0T3BlbkNsaWVudEZhaWxlZBIhCgx0Y3BfaW5mb19ydG8YvwkgASgN' - 'Ugp0Y3BJbmZvUnRvEiEKDHRjcF9pbmZvX2F0bxjACSABKA1SCnRjcEluZm9BdG8SKAoQdGNwX2' - 'luZm9fc25kX21zcxjBCSABKA1SDXRjcEluZm9TbmRNc3MSKAoQdGNwX2luZm9fcmN2X21zcxjC' - 'CSABKA1SDXRjcEluZm9SY3ZNc3MSKQoQdGNwX2luZm9fdW5hY2tlZBjDCSABKA1SDnRjcEluZm' - '9VbmFja2VkEicKD3RjcF9pbmZvX3NhY2tlZBjECSABKA1SDXRjcEluZm9TYWNrZWQSIwoNdGNw' - 'X2luZm9fbG9zdBjFCSABKA1SC3RjcEluZm9Mb3N0EikKEHRjcF9pbmZvX3JldHJhbnMYxgkgAS' - 'gNUg50Y3BJbmZvUmV0cmFucxIpChB0Y3BfaW5mb19mYWNrZXRzGMcJIAEoDVIOdGNwSW5mb0Zh' - 'Y2tldHMSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3NlbnQYyAkgASgNUhN0Y3BJbmZvTGFzdERhdG' - 'FTZW50EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3NlbnQYyQkgASgNUhJ0Y3BJbmZvTGFzdEFja1Nl' - 'bnQSNQoXdGNwX2luZm9fbGFzdF9kYXRhX3JlY3YYygkgASgNUhN0Y3BJbmZvTGFzdERhdGFSZW' - 'N2EjMKFnRjcF9pbmZvX2xhc3RfYWNrX3JlY3YYywkgASgNUhJ0Y3BJbmZvTGFzdEFja1JlY3YS' - 'IwoNdGNwX2luZm9fcG10dRjMCSABKA1SC3RjcEluZm9QbXR1EjIKFXRjcF9pbmZvX3Jjdl9zc3' - 'RocmVzaBjNCSABKA1SEnRjcEluZm9SY3ZTc3RocmVzaBIhCgx0Y3BfaW5mb19ydHQYzgkgASgN' - 'Ugp0Y3BJbmZvUnR0EigKEHRjcF9pbmZvX3J0dF92YXIYzwkgASgNUg10Y3BJbmZvUnR0VmFyEj' - 'IKFXRjcF9pbmZvX3NuZF9zc3RocmVzaBjQCSABKA1SEnRjcEluZm9TbmRTc3RocmVzaBIqChF0' - 'Y3BfaW5mb19zbmRfY3duZBjRCSABKA1SDnRjcEluZm9TbmRDd25kEigKEHRjcF9pbmZvX2Fkdl' - '9tc3MY0gkgASgNUg10Y3BJbmZvQWR2TXNzEi8KE3RjcF9pbmZvX3Jlb3JkZXJpbmcY0wkgASgN' - 'UhF0Y3BJbmZvUmVvcmRlcmluZxIoChB0Y3BfaW5mb19yY3ZfcnR0GNQJIAEoDVINdGNwSW5mb1' - 'JjdlJ0dBIsChJ0Y3BfaW5mb19yY3Zfc3BhY2UY1QkgASgNUg90Y3BJbmZvUmN2U3BhY2USNAoW' - 'dGNwX2luZm9fdG90YWxfcmV0cmFucxjWCSABKA1SE3RjcEluZm9Ub3RhbFJldHJhbnMSMAoUdG' - 'NwX2luZm9fcGFjaW5nX3JhdGUY1wkgASgEUhF0Y3BJbmZvUGFjaW5nUmF0ZRI3Chh0Y3BfaW5m' - 'b19tYXhfcGFjaW5nX3JhdGUY2AkgASgEUhR0Y3BJbmZvTWF4UGFjaW5nUmF0ZRIwChR0Y3BfaW' - '5mb19ieXRlc19hY2tlZBjZCSABKARSEXRjcEluZm9CeXRlc0Fja2VkEjYKF3RjcF9pbmZvX2J5' - 'dGVzX3JlY2VpdmVkGNoJIAEoBFIUdGNwSW5mb0J5dGVzUmVjZWl2ZWQSKgoRdGNwX2luZm9fc2' - 'Vnc19vdXQY2wkgASgNUg50Y3BJbmZvU2Vnc091dBIoChB0Y3BfaW5mb19zZWdzX2luGNwJIAEo' - 'DVINdGNwSW5mb1NlZ3NJbhI1Chd0Y3BfaW5mb19ub3Rfc2VudF9ieXRlcxjdCSABKA1SE3RjcE' - 'luZm9Ob3RTZW50Qnl0ZXMSKAoQdGNwX2luZm9fbWluX3J0dBjeCSABKA1SDXRjcEluZm9NaW5S' - 'dHQSMQoVdGNwX2luZm9fZGF0YV9zZWdzX2luGN8JIAEoDVIRdGNwSW5mb0RhdGFTZWdzSW4SMw' - 'oWdGNwX2luZm9fZGF0YV9zZWdzX291dBjgCSABKA1SEnRjcEluZm9EYXRhU2Vnc091dBI0ChZ0' - 'Y3BfaW5mb19kZWxpdmVyeV9yYXRlGOEJIAEoBFITdGNwSW5mb0RlbGl2ZXJ5UmF0ZRIsChJ0Y3' - 'BfaW5mb19idXN5X3RpbWUY4gkgASgEUg90Y3BJbmZvQnVzeVRpbWUSMgoVdGNwX2luZm9fcndu' - 'ZF9saW1pdGVkGOMJIAEoBFISdGNwSW5mb1J3bmRMaW1pdGVkEjYKF3RjcF9pbmZvX3NuZGJ1Zl' - '9saW1pdGVkGOQJIAEoBFIUdGNwSW5mb1NuZGJ1ZkxpbWl0ZWQSLQoSdGNwX2luZm9fZGVsaXZl' - 'cmVkGOUJIAEoDVIQdGNwSW5mb0RlbGl2ZXJlZBIyChV0Y3BfaW5mb19kZWxpdmVyZWRfY2UY5g' - 'kgASgNUhJ0Y3BJbmZvRGVsaXZlcmVkQ2USLgoTdGNwX2luZm9fYnl0ZXNfc2VudBjnCSABKARS' - 'EHRjcEluZm9CeXRlc1NlbnQSNAoWdGNwX2luZm9fYnl0ZXNfcmV0cmFucxjoCSABKARSE3RjcE' - 'luZm9CeXRlc1JldHJhbnMSLgoTdGNwX2luZm9fZHNhY2tfZHVwcxjpCSABKA1SEHRjcEluZm9E' - 'c2Fja0R1cHMSLgoTdGNwX2luZm9fcmVvcmRfc2VlbhjqCSABKA1SEHRjcEluZm9SZW9yZFNlZW' - '4SMAoUdGNwX2luZm9fcmN2X29vb3BhY2sY6wkgASgNUhF0Y3BJbmZvUmN2T29vcGFjaxIoChB0' - 'Y3BfaW5mb19zbmRfd25kGOwJIAEoDVINdGNwSW5mb1NuZFduZBIoChB0Y3BfaW5mb19yY3Zfd2' - '5kGO0JIAEoDVINdGNwSW5mb1JjdlduZBInCg90Y3BfaW5mb19yZWhhc2gY7gkgASgNUg10Y3BJ' - 'bmZvUmVoYXNoEiwKEnRjcF9pbmZvX3RvdGFsX3J0bxjvCSABKA1SD3RjcEluZm9Ub3RhbFJ0bx' - 'JBCh10Y3BfaW5mb190b3RhbF9ydG9fcmVjb3ZlcmllcxjwCSABKA1SGXRjcEluZm9Ub3RhbFJ0' - 'b1JlY292ZXJpZXMSNQoXdGNwX2luZm9fdG90YWxfcnRvX3RpbWUY8QkgASgNUhN0Y3BJbmZvVG' - '90YWxSdG9UaW1lEj8KG2Nvbmdlc3Rpb25fYWxnb3JpdGhtX3N0cmluZxiUCiABKAlSGWNvbmdl' - 'c3Rpb25BbGdvcml0aG1TdHJpbmcSdAoZY29uZ2VzdGlvbl9hbGdvcml0aG1fZW51bRiVCiABKA' - '4yNy54dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbGF0UmVjb3JkLkNvbmdlc3Rpb25BbGdvcml0' - 'aG1SF2Nvbmdlc3Rpb25BbGdvcml0aG1FbnVtEicKD3R5cGVfb2Zfc2VydmljZRj5CiABKA1SDX' - 'R5cGVPZlNlcnZpY2USJAoNdHJhZmZpY19jbGFzcxj6CiABKA1SDHRyYWZmaWNDbGFzcxIzChZz' - 'a19tZW1faW5mb19ybWVtX2FsbG9jGN0LIAEoDVISc2tNZW1JbmZvUm1lbUFsbG9jEi0KE3NrX2' - '1lbV9pbmZvX3Jjdl9idWYY3gsgASgNUg9za01lbUluZm9SY3ZCdWYSMwoWc2tfbWVtX2luZm9f' - 'd21lbV9hbGxvYxjfCyABKA1SEnNrTWVtSW5mb1dtZW1BbGxvYxItChNza19tZW1faW5mb19zbm' - 'RfYnVmGOALIAEoDVIPc2tNZW1JbmZvU25kQnVmEjEKFXNrX21lbV9pbmZvX2Z3ZF9hbGxvYxjh' - 'CyABKA1SEXNrTWVtSW5mb0Z3ZEFsbG9jEjUKF3NrX21lbV9pbmZvX3dtZW1fcXVldWVkGOILIA' - 'EoDVITc2tNZW1JbmZvV21lbVF1ZXVlZBIsChJza19tZW1faW5mb19vcHRtZW0Y4wsgASgNUg9z' - 'a01lbUluZm9PcHRtZW0SLgoTc2tfbWVtX2luZm9fYmFja2xvZxjkCyABKA1SEHNrTWVtSW5mb0' - 'JhY2tsb2cSKgoRc2tfbWVtX2luZm9fZHJvcHMY5QsgASgNUg5za01lbUluZm9Ecm9wcxImCg5z' - 'aHV0ZG93bl9zdGF0ZRjADCABKA1SDXNodXRkb3duU3RhdGUSLQoSdmVnYXNfaW5mb19lbmFibG' - 'VkGKUNIAEoDVIQdmVnYXNJbmZvRW5hYmxlZBIsChJ2ZWdhc19pbmZvX3J0dF9jbnQYpg0gASgN' - 'Ug92ZWdhc0luZm9SdHRDbnQSJQoOdmVnYXNfaW5mb19ydHQYpw0gASgNUgx2ZWdhc0luZm9SdH' - 'QSLAoSdmVnYXNfaW5mb19taW5fcnR0GKgNIAEoDVIPdmVnYXNJbmZvTWluUnR0Ei0KEmRjdGNw' - 'X2luZm9fZW5hYmxlZBiJDiABKA1SEGRjdGNwSW5mb0VuYWJsZWQSLgoTZGN0Y3BfaW5mb19jZV' - '9zdGF0ZRiKDiABKA1SEGRjdGNwSW5mb0NlU3RhdGUSKQoQZGN0Y3BfaW5mb19hbHBoYRiLDiAB' - 'KA1SDmRjdGNwSW5mb0FscGhhEioKEWRjdGNwX2luZm9fYWJfZWNuGIwOIAEoDVIOZGN0Y3BJbm' - 'ZvQWJFY24SKgoRZGN0Y3BfaW5mb19hYl90b3QYjQ4gASgNUg5kY3RjcEluZm9BYlRvdBIkCg5i' - 'YnJfaW5mb19id19sbxjtDiABKA1SC2JickluZm9Cd0xvEiQKDmJicl9pbmZvX2J3X2hpGO4OIA' - 'EoDVILYmJySW5mb0J3SGkSKAoQYmJyX2luZm9fbWluX3J0dBjvDiABKA1SDWJickluZm9NaW5S' - 'dHQSMAoUYmJyX2luZm9fcGFjaW5nX2dhaW4Y8A4gASgNUhFiYnJJbmZvUGFjaW5nR2FpbhIsCh' - 'JiYnJfaW5mb19jd25kX2dhaW4Y8Q4gASgNUg9iYnJJbmZvQ3duZEdhaW4SGgoIY2xhc3NfaWQY' - '0Q8gASgNUgdjbGFzc0lkEhoKCHNvY2tfb3B0GNIPIAEoDVIHc29ja09wdBIYCgdjX2dyb3VwGL' - 'cQIAEoBFIGY0dyb3VwImcKCExvY2FsaXR5EhgKFExPQ0FMSVRZX1VOU1BFQ0lGSUVEEAASEQoN' - 'TE9DQUxJVFlfU0VMRhABEhkKFUxPQ0FMSVRZX0xPQ0FMX1NVQk5FVBACEhMKD0xPQ0FMSVRZX1' - 'JFTU9URRADIpkCChNDb25nZXN0aW9uQWxnb3JpdGhtEiQKIENPTkdFU1RJT05fQUxHT1JJVEhN' - 'X1VOU1BFQ0lGSUVEEAASHgoaQ09OR0VTVElPTl9BTEdPUklUSE1fQ1VCSUMQARIeChpDT05HRV' - 'NUSU9OX0FMR09SSVRITV9EQ1RDUBACEh4KGkNPTkdFU1RJT05fQUxHT1JJVEhNX1ZFR0FTEAMS' - 'HwobQ09OR0VTVElPTl9BTEdPUklUSE1fUFJBR1VFEAQSHQoZQ09OR0VTVElPTl9BTEdPUklUSE' - '1fQkJSMRAFEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JCUjIQBhIdChlDT05HRVNUSU9OX0FM' - 'R09SSVRITV9CQlIzEAc='); + 'c2NyEkAKHGVucmljaF9zb2NrZXRfaW50ZXJmYWNlX25hbWUYrAIgASgJUhllbnJpY2hTb2NrZX' + 'RJbnRlcmZhY2VOYW1lEmwKG2VucmljaF9zb2NrZXRfZGVzdF9sb2NhbGl0eRi2AiABKA4yLC54' + 'dGNwX2ZsYXRfcmVjb3JkLnYxLlh0Y3BGbGF0UmVjb3JkLkxvY2FsaXR5UhhlbnJpY2hTb2NrZX' + 'REZXN0TG9jYWxpdHkSSQohZW5yaWNoX3NvY2tldF9kZXN0X2VncmVzc19pZmluZGV4GLcCIAEo' + 'DVIdZW5yaWNoU29ja2V0RGVzdEVncmVzc0lmaW5kZXgSRwogZW5yaWNoX3NvY2tldF9kZXN0X2' + 'VncmVzc19pZm5hbWUYuAIgASgJUhxlbnJpY2hTb2NrZXREZXN0RWdyZXNzSWZuYW1lEjQKFmVu' + 'cmljaF9zb2NrZXRfZGVzdF9hc24YwAIgASgEUhNlbnJpY2hTb2NrZXREZXN0QXNuEkQKH2Vucm' + 'ljaF9zb2NrZXRfZGVzdF9uZXh0X2hvcF9hc24YwQIgASgEUhplbnJpY2hTb2NrZXREZXN0TmV4' + 'dEhvcEFzbhJHCiBlbnJpY2hfc29ja2V0X2Rlc3RfbmV0d29ya19vd25lchjCAiABKAlSHGVucm' + 'ljaFNvY2tldERlc3ROZXR3b3JrT3duZXISMAoUaW5ldF9kaWFnX21zZ19mYW1pbHkY6QcgASgN' + 'UhFpbmV0RGlhZ01zZ0ZhbWlseRIuChNpbmV0X2RpYWdfbXNnX3N0YXRlGOoHIAEoDVIQaW5ldE' + 'RpYWdNc2dTdGF0ZRIuChNpbmV0X2RpYWdfbXNnX3RpbWVyGOsHIAEoDVIQaW5ldERpYWdNc2dU' + 'aW1lchIyChVpbmV0X2RpYWdfbXNnX3JldHJhbnMY7AcgASgNUhJpbmV0RGlhZ01zZ1JldHJhbn' + 'MSRgogaW5ldF9kaWFnX21zZ19zb2NrZXRfc291cmNlX3BvcnQY7QcgASgNUhtpbmV0RGlhZ01z' + 'Z1NvY2tldFNvdXJjZVBvcnQSUAolaW5ldF9kaWFnX21zZ19zb2NrZXRfZGVzdGluYXRpb25fcG' + '9ydBjuByABKA1SIGluZXREaWFnTXNnU29ja2V0RGVzdGluYXRpb25Qb3J0Ej0KG2luZXRfZGlh' + 'Z19tc2dfc29ja2V0X3NvdXJjZRjvByABKAxSF2luZXREaWFnTXNnU29ja2V0U291cmNlEkcKIG' + 'luZXRfZGlhZ19tc2dfc29ja2V0X2Rlc3RpbmF0aW9uGPAHIAEoDFIcaW5ldERpYWdNc2dTb2Nr' + 'ZXREZXN0aW5hdGlvbhJDCh5pbmV0X2RpYWdfbXNnX3NvY2tldF9pbnRlcmZhY2UY8QcgASgNUh' + 'ppbmV0RGlhZ01zZ1NvY2tldEludGVyZmFjZRI9ChtpbmV0X2RpYWdfbXNnX3NvY2tldF9jb29r' + 'aWUY8gcgASgEUhdpbmV0RGlhZ01zZ1NvY2tldENvb2tpZRIyChVpbmV0X2RpYWdfbXNnX2V4cG' + 'lyZXMY9QcgASgNUhJpbmV0RGlhZ01zZ0V4cGlyZXMSMAoUaW5ldF9kaWFnX21zZ19ycXVldWUY' + '9gcgASgNUhFpbmV0RGlhZ01zZ1JxdWV1ZRIwChRpbmV0X2RpYWdfbXNnX3dxdWV1ZRj3ByABKA' + '1SEWluZXREaWFnTXNnV3F1ZXVlEioKEWluZXRfZGlhZ19tc2dfdWlkGPgHIAEoDVIOaW5ldERp' + 'YWdNc2dVaWQSLgoTaW5ldF9kaWFnX21zZ19pbm9kZRj5ByABKA1SEGluZXREaWFnTXNnSW5vZG' + 'USIwoNbWVtX2luZm9fcm1lbRjNCCABKA1SC21lbUluZm9SbWVtEiMKDW1lbV9pbmZvX3dtZW0Y' + 'zgggASgNUgttZW1JbmZvV21lbRIjCg1tZW1faW5mb19mbWVtGM8IIAEoDVILbWVtSW5mb0ZtZW' + '0SIwoNbWVtX2luZm9fdG1lbRjQCCABKA1SC21lbUluZm9UbWVtEiUKDnRjcF9pbmZvX3N0YXRl' + 'GLEJIAEoDVIMdGNwSW5mb1N0YXRlEioKEXRjcF9pbmZvX2NhX3N0YXRlGLIJIAEoDVIOdGNwSW' + '5mb0NhU3RhdGUSMQoUdGNwX2luZm9fcmV0cmFuc21pdHMYswkgASgNUhJ0Y3BJbmZvUmV0cmFu' + 'c21pdHMSJwoPdGNwX2luZm9fcHJvYmVzGLQJIAEoDVINdGNwSW5mb1Byb2JlcxIpChB0Y3BfaW' + '5mb19iYWNrb2ZmGLUJIAEoDVIOdGNwSW5mb0JhY2tvZmYSKQoQdGNwX2luZm9fb3B0aW9ucxi2' + 'CSABKA1SDnRjcEluZm9PcHRpb25zEi4KE3RjcF9pbmZvX3NuZF93c2NhbGUYtwkgASgNUhB0Y3' + 'BJbmZvU25kV3NjYWxlEi4KE3RjcF9pbmZvX3Jjdl93c2NhbGUYuAkgASgNUhB0Y3BJbmZvUmN2' + 'V3NjYWxlEkoKInRjcF9pbmZvX2RlbGl2ZXJ5X3JhdGVfYXBwX2xpbWl0ZWQYuQkgASgNUh10Y3' + 'BJbmZvRGVsaXZlcnlSYXRlQXBwTGltaXRlZBJBCh10Y3BfaW5mb19mYXN0b3Blbl9jbGllbnRf' + 'ZmFpbBi6CSABKA1SGXRjcEluZm9GYXN0b3BlbkNsaWVudEZhaWwSIQoMdGNwX2luZm9fcnRvGL' + '8JIAEoDVIKdGNwSW5mb1J0bxIhCgx0Y3BfaW5mb19hdG8YwAkgASgNUgp0Y3BJbmZvQXRvEigK' + 'EHRjcF9pbmZvX3NuZF9tc3MYwQkgASgNUg10Y3BJbmZvU25kTXNzEigKEHRjcF9pbmZvX3Jjdl' + '9tc3MYwgkgASgNUg10Y3BJbmZvUmN2TXNzEikKEHRjcF9pbmZvX3VuYWNrZWQYwwkgASgNUg50' + 'Y3BJbmZvVW5hY2tlZBInCg90Y3BfaW5mb19zYWNrZWQYxAkgASgNUg10Y3BJbmZvU2Fja2VkEi' + 'MKDXRjcF9pbmZvX2xvc3QYxQkgASgNUgt0Y3BJbmZvTG9zdBIpChB0Y3BfaW5mb19yZXRyYW5z' + 'GMYJIAEoDVIOdGNwSW5mb1JldHJhbnMSKQoQdGNwX2luZm9fZmFja2V0cxjHCSABKA1SDnRjcE' + 'luZm9GYWNrZXRzEjUKF3RjcF9pbmZvX2xhc3RfZGF0YV9zZW50GMgJIAEoDVITdGNwSW5mb0xh' + 'c3REYXRhU2VudBIzChZ0Y3BfaW5mb19sYXN0X2Fja19zZW50GMkJIAEoDVISdGNwSW5mb0xhc3' + 'RBY2tTZW50EjUKF3RjcF9pbmZvX2xhc3RfZGF0YV9yZWN2GMoJIAEoDVITdGNwSW5mb0xhc3RE' + 'YXRhUmVjdhIzChZ0Y3BfaW5mb19sYXN0X2Fja19yZWN2GMsJIAEoDVISdGNwSW5mb0xhc3RBY2' + 'tSZWN2EiMKDXRjcF9pbmZvX3BtdHUYzAkgASgNUgt0Y3BJbmZvUG10dRIyChV0Y3BfaW5mb19y' + 'Y3Zfc3N0aHJlc2gYzQkgASgNUhJ0Y3BJbmZvUmN2U3N0aHJlc2gSIQoMdGNwX2luZm9fcnR0GM' + '4JIAEoDVIKdGNwSW5mb1J0dBInCg90Y3BfaW5mb19ydHR2YXIYzwkgASgNUg10Y3BJbmZvUnR0' + 'dmFyEjIKFXRjcF9pbmZvX3NuZF9zc3RocmVzaBjQCSABKA1SEnRjcEluZm9TbmRTc3RocmVzaB' + 'IqChF0Y3BfaW5mb19zbmRfY3duZBjRCSABKA1SDnRjcEluZm9TbmRDd25kEicKD3RjcF9pbmZv' + 'X2Fkdm1zcxjSCSABKA1SDXRjcEluZm9BZHZtc3MSLwoTdGNwX2luZm9fcmVvcmRlcmluZxjTCS' + 'ABKA1SEXRjcEluZm9SZW9yZGVyaW5nEigKEHRjcF9pbmZvX3Jjdl9ydHQY1AkgASgNUg10Y3BJ' + 'bmZvUmN2UnR0EiwKEnRjcF9pbmZvX3Jjdl9zcGFjZRjVCSABKA1SD3RjcEluZm9SY3ZTcGFjZR' + 'I0ChZ0Y3BfaW5mb190b3RhbF9yZXRyYW5zGNYJIAEoDVITdGNwSW5mb1RvdGFsUmV0cmFucxIw' + 'ChR0Y3BfaW5mb19wYWNpbmdfcmF0ZRjXCSABKARSEXRjcEluZm9QYWNpbmdSYXRlEjcKGHRjcF' + '9pbmZvX21heF9wYWNpbmdfcmF0ZRjYCSABKARSFHRjcEluZm9NYXhQYWNpbmdSYXRlEjAKFHRj' + 'cF9pbmZvX2J5dGVzX2Fja2VkGNkJIAEoBFIRdGNwSW5mb0J5dGVzQWNrZWQSNgoXdGNwX2luZm' + '9fYnl0ZXNfcmVjZWl2ZWQY2gkgASgEUhR0Y3BJbmZvQnl0ZXNSZWNlaXZlZBIqChF0Y3BfaW5m' + 'b19zZWdzX291dBjbCSABKA1SDnRjcEluZm9TZWdzT3V0EigKEHRjcF9pbmZvX3NlZ3NfaW4Y3A' + 'kgASgNUg10Y3BJbmZvU2Vnc0luEjQKFnRjcF9pbmZvX25vdHNlbnRfYnl0ZXMY3QkgASgNUhN0' + 'Y3BJbmZvTm90c2VudEJ5dGVzEigKEHRjcF9pbmZvX21pbl9ydHQY3gkgASgNUg10Y3BJbmZvTW' + 'luUnR0EjEKFXRjcF9pbmZvX2RhdGFfc2Vnc19pbhjfCSABKA1SEXRjcEluZm9EYXRhU2Vnc0lu' + 'EjMKFnRjcF9pbmZvX2RhdGFfc2Vnc19vdXQY4AkgASgNUhJ0Y3BJbmZvRGF0YVNlZ3NPdXQSNA' + 'oWdGNwX2luZm9fZGVsaXZlcnlfcmF0ZRjhCSABKARSE3RjcEluZm9EZWxpdmVyeVJhdGUSLAoS' + 'dGNwX2luZm9fYnVzeV90aW1lGOIJIAEoBFIPdGNwSW5mb0J1c3lUaW1lEjIKFXRjcF9pbmZvX3' + 'J3bmRfbGltaXRlZBjjCSABKARSEnRjcEluZm9Sd25kTGltaXRlZBI2Chd0Y3BfaW5mb19zbmRi' + 'dWZfbGltaXRlZBjkCSABKARSFHRjcEluZm9TbmRidWZMaW1pdGVkEi0KEnRjcF9pbmZvX2RlbG' + 'l2ZXJlZBjlCSABKA1SEHRjcEluZm9EZWxpdmVyZWQSMgoVdGNwX2luZm9fZGVsaXZlcmVkX2Nl' + 'GOYJIAEoDVISdGNwSW5mb0RlbGl2ZXJlZENlEi4KE3RjcF9pbmZvX2J5dGVzX3NlbnQY5wkgAS' + 'gEUhB0Y3BJbmZvQnl0ZXNTZW50EjQKFnRjcF9pbmZvX2J5dGVzX3JldHJhbnMY6AkgASgEUhN0' + 'Y3BJbmZvQnl0ZXNSZXRyYW5zEi4KE3RjcF9pbmZvX2RzYWNrX2R1cHMY6QkgASgNUhB0Y3BJbm' + 'ZvRHNhY2tEdXBzEi4KE3RjcF9pbmZvX3Jlb3JkX3NlZW4Y6gkgASgNUhB0Y3BJbmZvUmVvcmRT' + 'ZWVuEjAKFHRjcF9pbmZvX3Jjdl9vb29wYWNrGOsJIAEoDVIRdGNwSW5mb1Jjdk9vb3BhY2sSKA' + 'oQdGNwX2luZm9fc25kX3duZBjsCSABKA1SDXRjcEluZm9TbmRXbmQSKAoQdGNwX2luZm9fcmN2' + 'X3duZBjtCSABKA1SDXRjcEluZm9SY3ZXbmQSJwoPdGNwX2luZm9fcmVoYXNoGO4JIAEoDVINdG' + 'NwSW5mb1JlaGFzaBIsChJ0Y3BfaW5mb190b3RhbF9ydG8Y7wkgASgNUg90Y3BJbmZvVG90YWxS' + 'dG8SQQoddGNwX2luZm9fdG90YWxfcnRvX3JlY292ZXJpZXMY8AkgASgNUhl0Y3BJbmZvVG90YW' + 'xSdG9SZWNvdmVyaWVzEjUKF3RjcF9pbmZvX3RvdGFsX3J0b190aW1lGPEJIAEoDVITdGNwSW5m' + 'b1RvdGFsUnRvVGltZRIlCg5pbmV0X2RpYWdfY29uZxiUCiABKAlSDGluZXREaWFnQ29uZxJnCh' + 'NpbmV0X2RpYWdfY29uZ19lbnVtGJUKIAEoDjI3Lnh0Y3BfZmxhdF9yZWNvcmQudjEuWHRjcEZs' + 'YXRSZWNvcmQuQ29uZ2VzdGlvbkFsZ29yaXRobVIQaW5ldERpYWdDb25nRW51bRIjCg1pbmV0X2' + 'RpYWdfdG9zGPkKIAEoDVILaW5ldERpYWdUb3MSKQoQaW5ldF9kaWFnX3RjbGFzcxj6CiABKA1S' + 'DmluZXREaWFnVGNsYXNzEjMKFnNrX21lbV9pbmZvX3JtZW1fYWxsb2MY3QsgASgNUhJza01lbU' + 'luZm9SbWVtQWxsb2MSLAoSc2tfbWVtX2luZm9fcmN2YnVmGN4LIAEoDVIPc2tNZW1JbmZvUmN2' + 'YnVmEjMKFnNrX21lbV9pbmZvX3dtZW1fYWxsb2MY3wsgASgNUhJza01lbUluZm9XbWVtQWxsb2' + 'MSLAoSc2tfbWVtX2luZm9fc25kYnVmGOALIAEoDVIPc2tNZW1JbmZvU25kYnVmEjEKFXNrX21l' + 'bV9pbmZvX2Z3ZF9hbGxvYxjhCyABKA1SEXNrTWVtSW5mb0Z3ZEFsbG9jEjUKF3NrX21lbV9pbm' + 'ZvX3dtZW1fcXVldWVkGOILIAEoDVITc2tNZW1JbmZvV21lbVF1ZXVlZBIsChJza19tZW1faW5m' + 'b19vcHRtZW0Y4wsgASgNUg9za01lbUluZm9PcHRtZW0SLgoTc2tfbWVtX2luZm9fYmFja2xvZx' + 'jkCyABKA1SEHNrTWVtSW5mb0JhY2tsb2cSKgoRc2tfbWVtX2luZm9fZHJvcHMY5QsgASgNUg5z' + 'a01lbUluZm9Ecm9wcxItChJpbmV0X2RpYWdfc2h1dGRvd24YwAwgASgNUhBpbmV0RGlhZ1NodX' + 'Rkb3duEi0KEnZlZ2FzX2luZm9fZW5hYmxlZBilDSABKA1SEHZlZ2FzSW5mb0VuYWJsZWQSKwoR' + 'dmVnYXNfaW5mb19ydHRjbnQYpg0gASgNUg92ZWdhc0luZm9SdHRjbnQSJQoOdmVnYXNfaW5mb1' + '9ydHQYpw0gASgNUgx2ZWdhc0luZm9SdHQSKwoRdmVnYXNfaW5mb19taW5ydHQYqA0gASgNUg92' + 'ZWdhc0luZm9NaW5ydHQSLQoSZGN0Y3BfaW5mb19lbmFibGVkGIkOIAEoDVIQZGN0Y3BJbmZvRW' + '5hYmxlZBIuChNkY3RjcF9pbmZvX2NlX3N0YXRlGIoOIAEoDVIQZGN0Y3BJbmZvQ2VTdGF0ZRIp' + 'ChBkY3RjcF9pbmZvX2FscGhhGIsOIAEoDVIOZGN0Y3BJbmZvQWxwaGESKgoRZGN0Y3BfaW5mb1' + '9hYl9lY24YjA4gASgNUg5kY3RjcEluZm9BYkVjbhIqChFkY3RjcF9pbmZvX2FiX3RvdBiNDiAB' + 'KA1SDmRjdGNwSW5mb0FiVG90EiQKDmJicl9pbmZvX2J3X2xvGO0OIAEoDVILYmJySW5mb0J3TG' + '8SJAoOYmJyX2luZm9fYndfaGkY7g4gASgNUgtiYnJJbmZvQndIaRIoChBiYnJfaW5mb19taW5f' + 'cnR0GO8OIAEoDVINYmJySW5mb01pblJ0dBIwChRiYnJfaW5mb19wYWNpbmdfZ2FpbhjwDiABKA' + '1SEWJickluZm9QYWNpbmdHYWluEiwKEmJicl9pbmZvX2N3bmRfZ2FpbhjxDiABKA1SD2Jicklu' + 'Zm9Dd25kR2FpbhIsChJpbmV0X2RpYWdfY2xhc3NfaWQY0Q8gASgNUg9pbmV0RGlhZ0NsYXNzSW' + 'QSKwoRaW5ldF9kaWFnX3NvY2tvcHQY0g8gASgNUg9pbmV0RGlhZ1NvY2tvcHQSLgoTaW5ldF9k' + 'aWFnX2Nncm91cF9pZBjTDyABKARSEGluZXREaWFnQ2dyb3VwSWQiZwoITG9jYWxpdHkSGAoUTE' + '9DQUxJVFlfVU5TUEVDSUZJRUQQABIRCg1MT0NBTElUWV9TRUxGEAESGQoVTE9DQUxJVFlfTE9D' + 'QUxfU1VCTkVUEAISEwoPTE9DQUxJVFlfUkVNT1RFEAMimQIKE0Nvbmdlc3Rpb25BbGdvcml0aG' + '0SJAogQ09OR0VTVElPTl9BTEdPUklUSE1fVU5TUEVDSUZJRUQQABIeChpDT05HRVNUSU9OX0FM' + 'R09SSVRITV9DVUJJQxABEh4KGkNPTkdFU1RJT05fQUxHT1JJVEhNX0RDVENQEAISHgoaQ09OR0' + 'VTVElPTl9BTEdPUklUSE1fVkVHQVMQAxIfChtDT05HRVNUSU9OX0FMR09SSVRITV9QUkFHVUUQ' + 'BBIdChlDT05HRVNUSU9OX0FMR09SSVRITV9CQlIxEAUSHQoZQ09OR0VTVElPTl9BTEdPUklUSE' + '1fQkJSMhAGEh0KGUNPTkdFU1RJT05fQUxHT1JJVEhNX0JCUjMQB0oGCK0CEK4CSgYIrgIQrwJK' + 'BgjzBxD0B0oGCPQHEPUHSgYI+gcQ+wdKBgj7BxD8B0oGCLcQELgQUh1pbmV0X2RpYWdfbXNnX3' + 'NvY2tldF9kZXN0X2FzblIhaW5ldF9kaWFnX21zZ19zb2NrZXRfbmV4dF9ob3BfYXNuUidpbmV0' + 'X2RpYWdfbXNnX3NvY2tldF9kZXN0X25ldHdvcmtfb3duZXJSImluZXRfZGlhZ19tc2dfc29ja2' + 'V0X2Rlc3RfbG9jYWxpdHlSGmVucmljaF9zb2NrZXRfbmV4dF9ob3BfYXNuUhN0Y3BfaW5mb19z' + 'ZW5kX3NjYWxlUhJ0Y3BfaW5mb19yY3Zfc2NhbGVSIHRjcF9pbmZvX2Zhc3Rfb3Blbl9jbGllbn' + 'RfZmFpbGVkUhB0Y3BfaW5mb19ydHRfdmFyUhB0Y3BfaW5mb19hZHZfbXNzUhd0Y3BfaW5mb19u' + 'b3Rfc2VudF9ieXRlc1ITc2tfbWVtX2luZm9fcmN2X2J1ZlITc2tfbWVtX2luZm9fc25kX2J1Zl' + 'ISdmVnYXNfaW5mb19ydHRfY250UhJ2ZWdhc19pbmZvX21pbl9ydHRSG2Nvbmdlc3Rpb25fYWxn' + 'b3JpdGhtX3N0cmluZ1IZY29uZ2VzdGlvbl9hbGdvcml0aG1fZW51bVIPdHlwZV9vZl9zZXJ2aW' + 'NlUg10cmFmZmljX2NsYXNzUg5zaHV0ZG93bl9zdGF0ZVIIY2xhc3NfaWRSCHNvY2tfb3B0Ugdj' + 'X2dyb3Vw'); @$core.Deprecated('Use flatRecordsRequestDescriptor instead') const FlatRecordsRequest$json = { diff --git a/gen/go/xtcp_config/xtcp_config.pb.go b/gen/go/xtcp_config/xtcp_config.pb.go index dac3830..88bee4e 100644 --- a/gen/go/xtcp_config/xtcp_config.pb.go +++ b/gen/go/xtcp_config/xtcp_config.pb.go @@ -1,8 +1,8 @@ // // xTCP - config // -// These are all the structs relating to the TCP diagnotic module in the kernel -// +// Runtime configuration of the xtcp2 daemon, served and mutated over gRPC +// (ConfigService) and mirrored one-to-one by the cmd/xtcp2 CLI flags / env. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder @@ -689,6 +689,26 @@ func (x *SetEnvelopeFlushResponse) GetConfig() *XtcpConfig { } // xtcp configuration +// +// Field-number layout (renumbered into subject blocks 2026-09; the binary form +// is never persisted — it only crosses the gRPC hop between xtcp2 and +// xtcp2ctl/xtcp2client, which are built from this repo's gen/go together, and +// protojson/prototext map by NAME — so renumbering is safe). Add new knobs in +// the free space of the matching block; open a new block above 250 for a new +// subject. +// +// 10-39 polling & netlink (dump cadence, netlinker plumbing, io_uring) +// 40-49 namespace reconcile +// 50-59 capture / debug +// 60-79 output, destination-agnostic (dest, marshal, csv, envelope) +// 80-99 kafka destination +// 100-129 s3parquet destination +// 130-149 identity & labels stamped on every record +// 150-159 network knobs for xtcp2's own listeners +// 160-169 gRPC +// 170-179 profiling +// 200-249 best-effort enrichment (container 200s, lldp 210s, nic 220s, +// nsid 230s, asn 240-244, locality 245-249) type XtcpConfig struct { state protoimpl.MessageState `protogen:"open.v1"` // Netlink socket timeout in milliseconds @@ -698,38 +718,99 @@ type XtcpConfig struct { // This is how often xtcp sends the netlink dump request // Recommend not too frequently, so maybe 30s or 60s // https://pkg.go.dev/google.golang.org/protobuf/types/known/durationpb - PollFrequency *durationpb.Duration `protobuf:"bytes,20,opt,name=poll_frequency,json=pollFrequency,proto3" json:"poll_frequency,omitempty"` + PollFrequency *durationpb.Duration `protobuf:"bytes,11,opt,name=poll_frequency,json=pollFrequency,proto3" json:"poll_frequency,omitempty"` // Poll timeout per name space // Must be less than the poll frequency - PollTimeout *durationpb.Duration `protobuf:"bytes,30,opt,name=poll_timeout,json=pollTimeout,proto3" json:"poll_timeout,omitempty"` + PollTimeout *durationpb.Duration `protobuf:"bytes,12,opt,name=poll_timeout,json=pollTimeout,proto3" json:"poll_timeout,omitempty"` + // Maximum poll-schedule jitter as a percent of poll_frequency, applied to + // both the startup delay before the first poll and each subsequent tick. + // 0 disables (immediate first poll, fixed interval). Default 20. See + // docs/design-jitter-and-backoff.md. + PollJitterPct uint32 `protobuf:"varint,13,opt,name=poll_jitter_pct,json=pollJitterPct,proto3" json:"poll_jitter_pct,omitempty"` // Maximum number of loops, or zero (0) for forever - MaxLoops uint64 `protobuf:"varint,40,opt,name=max_loops,json=maxLoops,proto3" json:"max_loops,omitempty"` + MaxLoops uint64 `protobuf:"varint,14,opt,name=max_loops,json=maxLoops,proto3" json:"max_loops,omitempty"` // Netlinker goroutines per netlink socket ( recommend 1,2,4 range ) // Netlinkers read the tcp-diag response messages from the netlink socket // If you have a large number of - Netlinkers uint32 `protobuf:"varint,50,opt,name=netlinkers,proto3" json:"netlinkers,omitempty"` + Netlinkers uint32 `protobuf:"varint,15,opt,name=netlinkers,proto3" json:"netlinkers,omitempty"` // netlinkerDoneCh channel size // This channel is used between the netlinkers and the poller // Check the prom counter to see if the channel is too small // d.pC.WithLabelValues("Deserialize", "netlinkerDoneCh", "error").Inc() - NetlinkersDoneChanSize uint32 `protobuf:"varint,51,opt,name=netlinkers_done_chan_size,json=netlinkersDoneChanSize,proto3" json:"netlinkers_done_chan_size,omitempty"` + NetlinkersDoneChanSize uint32 `protobuf:"varint,16,opt,name=netlinkers_done_chan_size,json=netlinkersDoneChanSize,proto3" json:"netlinkers_done_chan_size,omitempty"` // nlmsg_seq sequence number (start). This gets incremented. - NlmsgSeq uint32 `protobuf:"varint,60,opt,name=nlmsg_seq,json=nlmsgSeq,proto3" json:"nlmsg_seq,omitempty"` + NlmsgSeq uint32 `protobuf:"varint,17,opt,name=nlmsg_seq,json=nlmsgSeq,proto3" json:"nlmsg_seq,omitempty"` // netlinker packetSize. buffer size = packetSize * packetSizeMply. Use zero (0) for syscall.Getpagesize() // recommend using 0 - PacketSize uint64 `protobuf:"varint,70,opt,name=packet_size,json=packetSize,proto3" json:"packet_size,omitempty"` + PacketSize uint64 `protobuf:"varint,18,opt,name=packet_size,json=packetSize,proto3" json:"packet_size,omitempty"` // netlinker packetSize multiplier. buffer size = packetSize * packetSizeMply - PacketSizeMply uint32 `protobuf:"varint,80,opt,name=packet_size_mply,json=packetSizeMply,proto3" json:"packet_size_mply,omitempty"` + PacketSizeMply uint32 `protobuf:"varint,19,opt,name=packet_size_mply,json=packetSizeMply,proto3" json:"packet_size_mply,omitempty"` + // modulus. Report every X socket diag messages to output + Modulus uint64 `protobuf:"varint,20,opt,name=modulus,proto3" json:"modulus,omitempty"` + // Which INET_DIAG_* extension deserializers run (keyed by short name: + // info, skmem, cong, tos, tc, shut, vegas, dctcp, bbr, classid, sockopt, + // cgroup, meminfo). Unset = daemon defaults. + EnabledDeserializers *EnabledDeserializers `protobuf:"bytes,21,opt,name=enabled_deserializers,json=enabledDeserializers,proto3" json:"enabled_deserializers,omitempty"` + // When true, route netlink reads and raw-socket destination writes + // through an io_uring ring per Netlinker. Requires Linux 6.1+. + // Library-backed destinations (kafka, nsq, nats, valkey) ignore this + // flag — they continue to use their own client sockets unchanged. + IoUring bool `protobuf:"varint,22,opt,name=io_uring,json=ioUring,proto3" json:"io_uring,omitempty"` + // Number of recvmsg SQEs kept in flight per Netlinker ring. Higher + // values reduce io_uring_enter syscalls per dump cycle on hosts with + // many sockets, at the cost of more pinned buffers from packet pool. + // Ignored unless io_uring=true. Default 64. + IoUringRecvBatchSize uint32 `protobuf:"varint,23,opt,name=io_uring_recv_batch_size,json=ioUringRecvBatchSize,proto3" json:"io_uring_recv_batch_size,omitempty"` + // Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise + // userland loop overhead but increase scheduling latency for the + // netlinker goroutine. Ignored unless io_uring=true. Default 128. + IoUringCqeBatchSize uint32 `protobuf:"varint,24,opt,name=io_uring_cqe_batch_size,json=ioUringCqeBatchSize,proto3" json:"io_uring_cqe_batch_size,omitempty"` + // Period of the background namespace-reconcile ticker (Method B /proc scan + // that converges the tracked namespace set). With reconcile_before_poll the + // Poller reconciles every cycle and is the real discovery mechanism, so this + // background pass is an occasional safety-net expected to find nothing + // (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) + // so operators can confirm from the counters that it is redundant. It still + // matters when the poller is idle or disabled. 0 disables the background + // ticker entirely (the startup reconcile still runs once). + ReconcileFrequency *durationpb.Duration `protobuf:"bytes,40,opt,name=reconcile_frequency,json=reconcileFrequency,proto3" json:"reconcile_frequency,omitempty"` + // Run a namespace reconcile immediately before each poll cycle, so a + // namespace that appeared since the last cycle is entered and gets a socket + // within ~1 poll interval instead of waiting for the background ticker. Ties + // discovery cadence to poll cadence; the /proc scan is zero-allocation and + // mutex-serialized with the background reconciler. Default true. + ReconcileBeforePoll bool `protobuf:"varint,41,opt,name=reconcile_before_poll,json=reconcileBeforePoll,proto3" json:"reconcile_before_poll,omitempty"` // Write netlink packets to writeFiles number of files ( to generate test data ) per netlinker // xtcp will capture this many Netlink response packets when it starts // This is PER netlinker - WriteFiles uint32 `protobuf:"varint,90,opt,name=write_files,json=writeFiles,proto3" json:"write_files,omitempty"` + WriteFiles uint32 `protobuf:"varint,50,opt,name=write_files,json=writeFiles,proto3" json:"write_files,omitempty"` // Write files path - CapturePath string `protobuf:"bytes,100,opt,name=capture_path,json=capturePath,proto3" json:"capture_path,omitempty"` - // modulus. Report every X socket diag messages to output - Modulus uint64 `protobuf:"varint,110,opt,name=modulus,proto3" json:"modulus,omitempty"` + CapturePath string `protobuf:"bytes,51,opt,name=capture_path,json=capturePath,proto3" json:"capture_path,omitempty"` + // Write marshalled data to dest_write_files number of files ( to allow debugging of the serialization ) + // xtcp will capture this many examples of the marshalled data + // This is PER poller + DestWriteFiles uint32 `protobuf:"varint,52,opt,name=dest_write_files,json=destWriteFiles,proto3" json:"dest_write_files,omitempty"` + // DebugLevel + DebugLevel uint32 `protobuf:"varint,53,opt,name=debug_level,json=debugLevel,proto3" json:"debug_level,omitempty"` + // kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, + // nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, + // unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or + // unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). + // max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the + // http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES + // and S3 endpoints the INSERT query + FORMAT + format_schema + auth query + // params routinely run ~150+ chars, which the old 128 cap rejected. + Dest string `protobuf:"bytes,60,opt,name=dest,proto3" json:"dest,omitempty"` // Marshalling of the exported data (protobufList,json,prototext) - MarshalTo string `protobuf:"bytes,120,opt,name=marshal_to,json=marshalTo,proto3" json:"marshal_to,omitempty"` + MarshalTo string `protobuf:"bytes,61,opt,name=marshal_to,json=marshalTo,proto3" json:"marshal_to,omitempty"` + // Comma-separated subset of XtcpFlatRecord json field names selecting + // which columns the csv/tsv marshallers emit (e.g. + // "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). + // Empty = all fields. Ignored by non-tabular marshallers. + CsvColumns string `protobuf:"bytes,62,opt,name=csv_columns,json=csvColumns,proto3" json:"csv_columns,omitempty"` + // XtcpProtoFile — path of the xtcp_flat_record.proto the daemon reads at + // startup and POSTs to the Kafka schema registry (kafka_schema_url). + XtcpProtoFile string `protobuf:"bytes,63,opt,name=xtcp_proto_file,json=xtcpProtoFile,proto3" json:"xtcp_proto_file,omitempty"` // Soft cap on the in-flight envelope's marshalled size, in bytes. // Measured via proto.Size — i.e. the UNCOMPRESSED serialized size. // franz-go applies ZSTD/LZ4/Snappy compression after handoff, so the @@ -742,7 +823,7 @@ type XtcpConfig struct { // Useful primarily as a safety net against records with huge // `bytes` fields. For everyday batch sizing, prefer the row-count // cap (envelope_flush_threshold_rows) below. - EnvelopeFlushThresholdBytes uint32 `protobuf:"varint,122,opt,name=envelope_flush_threshold_bytes,json=envelopeFlushThresholdBytes,proto3" json:"envelope_flush_threshold_bytes,omitempty"` + EnvelopeFlushThresholdBytes uint32 `protobuf:"varint,64,opt,name=envelope_flush_threshold_bytes,json=envelopeFlushThresholdBytes,proto3" json:"envelope_flush_threshold_bytes,omitempty"` // Soft cap on the in-flight envelope's row count. When the envelope // reaches this many rows, deserialize.go triggers an early mid-poll // flush. Cheaper than the byte cap (no proto.Size walk on the hot @@ -753,7 +834,15 @@ type XtcpConfig struct { // (EnvelopeFlushThresholdRowsCst, currently 10000 — chosen to align // with the ClickHouse kafka_max_rows_per_message setting so a // produced envelope never forces the consumer to split it). - EnvelopeFlushThresholdRows uint32 `protobuf:"varint,123,opt,name=envelope_flush_threshold_rows,json=envelopeFlushThresholdRows,proto3" json:"envelope_flush_threshold_rows,omitempty"` + EnvelopeFlushThresholdRows uint32 `protobuf:"varint,65,opt,name=envelope_flush_threshold_rows,json=envelopeFlushThresholdRows,proto3" json:"envelope_flush_threshold_rows,omitempty"` + // Kafka or NSQ topic + Topic string `protobuf:"bytes,80,opt,name=topic,proto3" json:"topic,omitempty"` + // Kafka schema registry url + KafkaSchemaUrl string `protobuf:"bytes,81,opt,name=kafka_schema_url,json=kafkaSchemaUrl,proto3" json:"kafka_schema_url,omitempty"` + // Kafka Produce context timeout. Use 0 for no context timeout + // Recommend a small timeout, like 1-2 seconds + // kgo seems to have a bug, because the timeout is always expired + KafkaProduceTimeout *durationpb.Duration `protobuf:"bytes,82,opt,name=kafka_produce_timeout,json=kafkaProduceTimeout,proto3" json:"kafka_produce_timeout,omitempty"` // Kafka producer-batch compression codec. franz-go picks one codec // from the supplied preference list that the broker advertises. // Both Redpanda and ClickHouse (via librdkafka on its Kafka engine) @@ -773,228 +862,172 @@ type XtcpConfig struct { // // Pick "lz4" if xtcp2 is CPU-bound on the producer side; pick // "zstd" (the default) if Kafka throughput / disk usage matters more. - KafkaCompression string `protobuf:"bytes,124,opt,name=kafka_compression,json=kafkaCompression,proto3" json:"kafka_compression,omitempty"` + KafkaCompression string `protobuf:"bytes,83,opt,name=kafka_compression,json=kafkaCompression,proto3" json:"kafka_compression,omitempty"` // S3 endpoint URL, e.g. "http://127.0.0.1:9000" (MinIO) or // "https://s3.amazonaws.com" (AWS). May be empty if -dest carries // it via the s3parquet: form. - S3Endpoint string `protobuf:"bytes,125,opt,name=s3_endpoint,json=s3Endpoint,proto3" json:"s3_endpoint,omitempty"` + S3Endpoint string `protobuf:"bytes,100,opt,name=s3_endpoint,json=s3Endpoint,proto3" json:"s3_endpoint,omitempty"` + // S3 region. Required by some S3 implementations even when talking + // to a single-region MinIO. Default "us-east-1" when blank. + S3Region string `protobuf:"bytes,101,opt,name=s3_region,json=s3Region,proto3" json:"s3_region,omitempty"` // Required when -dest s3parquet. Bucket must already exist on the // endpoint; the daemon does not auto-create. - S3Bucket string `protobuf:"bytes,126,opt,name=s3_bucket,json=s3Bucket,proto3" json:"s3_bucket,omitempty"` + S3Bucket string `protobuf:"bytes,102,opt,name=s3_bucket,json=s3Bucket,proto3" json:"s3_bucket,omitempty"` // Optional key-prefix WITHIN the bucket. Joined with the Hive-style // partition segments (host=…/date=…/hour=…/.parquet). Empty // = files land at the bucket root level. - S3Prefix string `protobuf:"bytes,127,opt,name=s3_prefix,json=s3Prefix,proto3" json:"s3_prefix,omitempty"` + S3Prefix string `protobuf:"bytes,103,opt,name=s3_prefix,json=s3Prefix,proto3" json:"s3_prefix,omitempty"` // Required when -dest s3parquet. Picked up from AWS_ACCESS_KEY_ID // env if blank. - S3AccessKey string `protobuf:"bytes,128,opt,name=s3_access_key,json=s3AccessKey,proto3" json:"s3_access_key,omitempty"` + S3AccessKey string `protobuf:"bytes,104,opt,name=s3_access_key,json=s3AccessKey,proto3" json:"s3_access_key,omitempty"` // Required when -dest s3parquet. Picked up from AWS_SECRET_ACCESS_KEY // env if blank. Never logged. - S3SecretKey string `protobuf:"bytes,129,opt,name=s3_secret_key,json=s3SecretKey,proto3" json:"s3_secret_key,omitempty"` - // Soft cap on the in-memory Parquet builder's accumulated - // uncompressed row bytes before the worker finalizes the file and - // uploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst). - // Operators tune down for faster file rotation (more S3 PUTs, - // smaller per-file query latency) or up for fewer larger files - // (better compression ratio, more memory). - S3ParquetFlushThresholdBytes uint32 `protobuf:"varint,132,opt,name=s3_parquet_flush_threshold_bytes,json=s3ParquetFlushThresholdBytes,proto3" json:"s3_parquet_flush_threshold_bytes,omitempty"` - // S3 region. Required by some S3 implementations even when talking - // to a single-region MinIO. Default "us-east-1" when blank. - S3Region string `protobuf:"bytes,133,opt,name=s3_region,json=s3Region,proto3" json:"s3_region,omitempty"` + S3SecretKey string `protobuf:"bytes,105,opt,name=s3_secret_key,json=s3SecretKey,proto3" json:"s3_secret_key,omitempty"` // Skip the startup S3 BucketExists probe. The probe issues a // HeadBucket, which requires the s3:ListBucket permission. Set true // when the upload credential is deliberately scoped to s3:PutObject // only (write-only key, e.g. a baked deployment credential) so the // daemon can start without list permission. Default false keeps the // fail-fast probe for normal deployments. - S3SkipBucketProbe bool `protobuf:"varint,134,opt,name=s3_skip_bucket_probe,json=s3SkipBucketProbe,proto3" json:"s3_skip_bucket_probe,omitempty"` - // Pyroscope continuous-profiling server URL (e.g. - // http://127.0.0.1:4040). When set, the daemon streams CPU, - // memory, goroutine, mutex, and block profiles to that endpoint. - // Empty disables the agent — no overhead in production runs that - // don't need it. Operators bring up a Pyroscope OSS server (or - // Grafana Cloud Pyroscope) and point xtcp2 at it for live profile - // data without restarts. - PyroscopeUrl string `protobuf:"bytes,136,opt,name=pyroscope_url,json=pyroscopeUrl,proto3" json:"pyroscope_url,omitempty"` - // Application name registered with the Pyroscope server (the - // "application" facet in the Pyroscope UI). Empty → "xtcp2". - // Set per fleet/role for multi-host environments - // (e.g. "xtcp2.prod.iad", "xtcp2.staging.fra"). - PyroscopeAppName string `protobuf:"bytes,137,opt,name=pyroscope_app_name,json=pyroscopeAppName,proto3" json:"pyroscope_app_name,omitempty"` - // CPU profile sampling rate in Hz. Default 100. The Pyroscope - // agent uses this to call runtime.SetCPUProfileRate at startup. - PyroscopeSampleHz uint32 `protobuf:"varint,138,opt,name=pyroscope_sample_hz,json=pyroscopeSampleHz,proto3" json:"pyroscope_sample_hz,omitempty"` - // Profile upload interval (seconds between batched profile - // pushes). Default 15 s. - PyroscopeUploadIntervalSec uint32 `protobuf:"varint,139,opt,name=pyroscope_upload_interval_sec,json=pyroscopeUploadIntervalSec,proto3" json:"pyroscope_upload_interval_sec,omitempty"` - // kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, - // nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, - // unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or - // unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). - // max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the - // http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES - // and S3 endpoints the INSERT query + FORMAT + format_schema + auth query - // params routinely run ~150+ chars, which the old 128 cap rejected. - Dest string `protobuf:"bytes,130,opt,name=dest,proto3" json:"dest,omitempty"` - // Write marhselled data to writeFiles number of files ( to allow debugging of the serialization ) - // xtcp will capture this many examples of the marshalled data - // This is PER poller - DestWriteFiles uint32 `protobuf:"varint,135,opt,name=dest_write_files,json=destWriteFiles,proto3" json:"dest_write_files,omitempty"` - // Kafka or NSQ topic - Topic string `protobuf:"bytes,140,opt,name=topic,proto3" json:"topic,omitempty"` - // XtcpProtoFile - XtcpProtoFile string `protobuf:"bytes,143,opt,name=xtcp_proto_file,json=xtcpProtoFile,proto3" json:"xtcp_proto_file,omitempty"` - // Kafka schema registry url - KafkaSchemaUrl string `protobuf:"bytes,145,opt,name=kafka_schema_url,json=kafkaSchemaUrl,proto3" json:"kafka_schema_url,omitempty"` - // Kafka Produce context timeout. Use 0 for no context timeout - // Recommend a small timeout, like 1-2 seconds - // kgo seems to have a bug, because the timeout is always expired - KafkaProduceTimeout *durationpb.Duration `protobuf:"bytes,150,opt,name=kafka_produce_timeout,json=kafkaProduceTimeout,proto3" json:"kafka_produce_timeout,omitempty"` - // DebugLevel - DebugLevel uint32 `protobuf:"varint,160,opt,name=debug_level,json=debugLevel,proto3" json:"debug_level,omitempty"` - // Label applied to the protobuf - Label string `protobuf:"bytes,170,opt,name=label,proto3" json:"label,omitempty"` - // Tag applied to the protobuf - Tag string `protobuf:"bytes,180,opt,name=tag,proto3" json:"tag,omitempty"` - // Deployment grouping / facility this daemon runs in (data center, PoP, - // region, site, …). Generic; stamped on every record's `location` field. - // Set via -location flag or LOCATION env. - Location string `protobuf:"bytes,181,opt,name=location,proto3" json:"location,omitempty"` + S3SkipBucketProbe bool `protobuf:"varint,106,opt,name=s3_skip_bucket_probe,json=s3SkipBucketProbe,proto3" json:"s3_skip_bucket_probe,omitempty"` + // Soft cap on the in-memory Parquet builder's accumulated + // uncompressed row bytes before the worker finalizes the file and + // uploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst). + // Operators tune down for faster file rotation (more S3 PUTs, + // smaller per-file query latency) or up for fewer larger files + // (better compression ratio, more memory). + S3ParquetFlushThresholdBytes uint32 `protobuf:"varint,110,opt,name=s3_parquet_flush_threshold_bytes,json=s3ParquetFlushThresholdBytes,proto3" json:"s3_parquet_flush_threshold_bytes,omitempty"` + // s3parquet staleness ceiling: force-flush the in-memory Parquet object + // after this long even if it hasn't reached the byte cap, bounding upload + // latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). + S3FlushInterval *durationpb.Duration `protobuf:"bytes,111,opt,name=s3_flush_interval,json=s3FlushInterval,proto3" json:"s3_flush_interval,omitempty"` + // Maximum jitter as a percent of s3_flush_interval, applied to the first + // timed flush and each interval so the fleet doesn't ceiling-flush in + // lockstep. 0 disables. Default 20. + S3FlushJitterPct uint32 `protobuf:"varint,112,opt,name=s3_flush_jitter_pct,json=s3FlushJitterPct,proto3" json:"s3_flush_jitter_pct,omitempty"` + // Per-object downward jitter as a percent of the s3parquet byte cap: each + // object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the + // size-cap upload path even under uniform load. Downward-only, so an + // object never exceeds the in-memory byte bound. 0 disables. Default 20. + S3FlushThresholdJitterPct uint32 `protobuf:"varint,113,opt,name=s3_flush_threshold_jitter_pct,json=s3FlushThresholdJitterPct,proto3" json:"s3_flush_threshold_jitter_pct,omitempty"` + // Maximum S3 upload attempts (original + retries) before dropping the + // object. Retries use full-jitter exponential backoff. Default 10. + S3UploadMaxAttempts uint32 `protobuf:"varint,114,opt,name=s3_upload_max_attempts,json=s3UploadMaxAttempts,proto3" json:"s3_upload_max_attempts,omitempty"` + // Cap on a single upload retry's backoff window (full jitter draws in + // [0, window], window grows exponentially up to this cap). 0 = derive as + // clamp(poll_frequency/10, 1s, 1h). + S3UploadBackoffCap *durationpb.Duration `protobuf:"bytes,115,opt,name=s3_upload_backoff_cap,json=s3UploadBackoffCap,proto3" json:"s3_upload_backoff_cap,omitempty"` // Hostname override. When empty the daemon uses os.Hostname(); set this to // stamp an explicit hostname on records — required in containers, where // os.Hostname() returns the container id, not the host. Set via -hostname // flag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the // container id). - Hostname string `protobuf:"bytes,182,opt,name=hostname,proto3" json:"hostname,omitempty"` + Hostname string `protobuf:"bytes,130,opt,name=hostname,proto3" json:"hostname,omitempty"` + // Deployment grouping / facility this daemon runs in (data center, PoP, + // region, site, …). Generic; stamped on every record's `location` field. + // Set via -location flag or LOCATION env. + Location string `protobuf:"bytes,131,opt,name=location,proto3" json:"location,omitempty"` + // Label applied to the protobuf + Label string `protobuf:"bytes,132,opt,name=label,proto3" json:"label,omitempty"` + // Tag applied to the protobuf + Tag string `protobuf:"bytes,133,opt,name=tag,proto3" json:"tag,omitempty"` // Daemon build provenance stamped on every record's `daemon_version` field // (git commit / date / version). Populated by the daemon from -ldflags build // vars, not a user flag; informational only (debugging which binary produced a // row). See XtcpFlatRecord.daemon_version. - DaemonVersion string `protobuf:"bytes,186,opt,name=daemon_version,json=daemonVersion,proto3" json:"daemon_version,omitempty"` - // Resolve each socket's owning container id from its cgroup (sets the - // record's container_id / container_runtime). Set via -resolveContainerId - // flag or CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it - // and run --cgroupns=host in a container). - ResolveContainerId bool `protobuf:"varint,183,opt,name=resolve_container_id,json=resolveContainerId,proto3" json:"resolve_container_id,omitempty"` + DaemonVersion string `protobuf:"bytes,134,opt,name=daemon_version,json=daemonVersion,proto3" json:"daemon_version,omitempty"` // Outgoing IPv4 TTL for xtcp2's own TCP listeners (Prometheus + gRPC). // 0 = kernel default. A low value (e.g. 3) keeps replies from travelling // far if the host is unexpectedly internet-exposed — the per-listener // analogue of the host nftables TTL clamp. Set via -ipv4Ttl / IPV4_TTL. // (cf. prometheus/exporter-toolkit#396.) - Ipv4Ttl uint32 `protobuf:"varint,184,opt,name=ipv4_ttl,json=ipv4Ttl,proto3" json:"ipv4_ttl,omitempty"` + Ipv4Ttl uint32 `protobuf:"varint,150,opt,name=ipv4_ttl,json=ipv4Ttl,proto3" json:"ipv4_ttl,omitempty"` // Outgoing IPv6 unicast hop limit for xtcp2's own TCP listeners. 0 = kernel // default. Same intent as ipv4_ttl. Set via -ipv6HopLimit / IPV6_HOP_LIMIT. - Ipv6HopLimit uint32 `protobuf:"varint,185,opt,name=ipv6_hop_limit,json=ipv6HopLimit,proto3" json:"ipv6_hop_limit,omitempty"` + Ipv6HopLimit uint32 `protobuf:"varint,151,opt,name=ipv6_hop_limit,json=ipv6HopLimit,proto3" json:"ipv6_hop_limit,omitempty"` // GRPC listening port - GrpcPort uint32 `protobuf:"varint,190,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"` - EnabledDeserializers *EnabledDeserializers `protobuf:"bytes,200,opt,name=enabled_deserializers,json=enabledDeserializers,proto3" json:"enabled_deserializers,omitempty"` - // When true, route netlink reads and raw-socket destination writes - // through an io_uring ring per Netlinker. Requires Linux 6.1+. - // Library-backed destinations (kafka, nsq, nats, valkey) ignore this - // flag — they continue to use their own client sockets unchanged. - IoUring bool `protobuf:"varint,210,opt,name=io_uring,json=ioUring,proto3" json:"io_uring,omitempty"` - // Number of recvmsg SQEs kept in flight per Netlinker ring. Higher - // values reduce io_uring_enter syscalls per dump cycle on hosts with - // many sockets, at the cost of more pinned buffers from packet pool. - // Ignored unless io_uring=true. Default 64. - IoUringRecvBatchSize uint32 `protobuf:"varint,211,opt,name=io_uring_recv_batch_size,json=ioUringRecvBatchSize,proto3" json:"io_uring_recv_batch_size,omitempty"` - // Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise - // userland loop overhead but increase scheduling latency for the - // netlinker goroutine. Ignored unless io_uring=true. Default 128. - IoUringCqeBatchSize uint32 `protobuf:"varint,212,opt,name=io_uring_cqe_batch_size,json=ioUringCqeBatchSize,proto3" json:"io_uring_cqe_batch_size,omitempty"` - // Comma-separated subset of XtcpFlatRecord json field names selecting - // which columns the csv/tsv marshallers emit (e.g. - // "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). - // Empty = all fields. Ignored by non-tabular marshallers. - CsvColumns string `protobuf:"bytes,220,opt,name=csv_columns,json=csvColumns,proto3" json:"csv_columns,omitempty"` - // Maximum poll-schedule jitter as a percent of poll_frequency, applied to - // both the startup delay before the first poll and each subsequent tick. - // 0 disables (immediate first poll, fixed interval). Default 20. - PollJitterPct uint32 `protobuf:"varint,221,opt,name=poll_jitter_pct,json=pollJitterPct,proto3" json:"poll_jitter_pct,omitempty"` - // s3parquet staleness ceiling: force-flush the in-memory Parquet object - // after this long even if it hasn't reached the byte cap, bounding upload - // latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). - S3FlushInterval *durationpb.Duration `protobuf:"bytes,222,opt,name=s3_flush_interval,json=s3FlushInterval,proto3" json:"s3_flush_interval,omitempty"` - // Maximum jitter as a percent of s3_flush_interval, applied to the first - // timed flush and each interval so the fleet doesn't ceiling-flush in - // lockstep. 0 disables. Default 20. - S3FlushJitterPct uint32 `protobuf:"varint,223,opt,name=s3_flush_jitter_pct,json=s3FlushJitterPct,proto3" json:"s3_flush_jitter_pct,omitempty"` - // Per-object downward jitter as a percent of the s3parquet byte cap: each - // object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the - // size-cap upload path even under uniform load. Downward-only, so an - // object never exceeds the in-memory byte bound. 0 disables. Default 20. - S3FlushThresholdJitterPct uint32 `protobuf:"varint,224,opt,name=s3_flush_threshold_jitter_pct,json=s3FlushThresholdJitterPct,proto3" json:"s3_flush_threshold_jitter_pct,omitempty"` - // Maximum S3 upload attempts (original + retries) before dropping the - // object. Retries use full-jitter exponential backoff. Default 10. - S3UploadMaxAttempts uint32 `protobuf:"varint,225,opt,name=s3_upload_max_attempts,json=s3UploadMaxAttempts,proto3" json:"s3_upload_max_attempts,omitempty"` - // Cap on a single upload retry's backoff window (full jitter draws in - // [0, window], window grows exponentially up to this cap). 0 = derive as - // clamp(poll_frequency/10, 1s, 1h). - S3UploadBackoffCap *durationpb.Duration `protobuf:"bytes,226,opt,name=s3_upload_backoff_cap,json=s3UploadBackoffCap,proto3" json:"s3_upload_backoff_cap,omitempty"` - // Period of the background namespace-reconcile ticker (Method B /proc scan - // that converges the tracked namespace set). With reconcile_before_poll the - // Poller reconciles every cycle and is the real discovery mechanism, so this - // background pass is an occasional safety-net expected to find nothing - // (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) - // so operators can confirm from the counters that it is redundant. It still - // matters when the poller is idle or disabled. 0 disables the background - // ticker entirely (the startup reconcile still runs once). - ReconcileFrequency *durationpb.Duration `protobuf:"bytes,227,opt,name=reconcile_frequency,json=reconcileFrequency,proto3" json:"reconcile_frequency,omitempty"` - // Run a namespace reconcile immediately before each poll cycle, so a - // namespace that appeared since the last cycle is entered and gets a socket - // within ~1 poll interval instead of waiting for the background ticker. Ties - // discovery cadence to poll cadence; the /proc scan is zero-allocation and - // mutex-serialized with the background reconciler. Default true. - ReconcileBeforePoll bool `protobuf:"varint,228,opt,name=reconcile_before_poll,json=reconcileBeforePoll,proto3" json:"reconcile_before_poll,omitempty"` + GrpcPort uint32 `protobuf:"varint,160,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"` + // Pyroscope continuous-profiling server URL (e.g. + // http://127.0.0.1:4040). When set, the daemon streams CPU, + // memory, goroutine, mutex, and block profiles to that endpoint. + // Empty disables the agent — no overhead in production runs that + // don't need it. Operators bring up a Pyroscope OSS server (or + // Grafana Cloud Pyroscope) and point xtcp2 at it for live profile + // data without restarts. + PyroscopeUrl string `protobuf:"bytes,170,opt,name=pyroscope_url,json=pyroscopeUrl,proto3" json:"pyroscope_url,omitempty"` + // Application name registered with the Pyroscope server (the + // "application" facet in the Pyroscope UI). Empty → "xtcp2". + // Set per fleet/role for multi-host environments + // (e.g. "xtcp2.prod.iad", "xtcp2.staging.fra"). + PyroscopeAppName string `protobuf:"bytes,171,opt,name=pyroscope_app_name,json=pyroscopeAppName,proto3" json:"pyroscope_app_name,omitempty"` + // CPU profile sampling rate in Hz. Default 100. The Pyroscope + // agent uses this to call runtime.SetCPUProfileRate at startup. + PyroscopeSampleHz uint32 `protobuf:"varint,172,opt,name=pyroscope_sample_hz,json=pyroscopeSampleHz,proto3" json:"pyroscope_sample_hz,omitempty"` + // Profile upload interval (seconds between batched profile + // pushes). Default 15 s. + PyroscopeUploadIntervalSec uint32 `protobuf:"varint,173,opt,name=pyroscope_upload_interval_sec,json=pyroscopeUploadIntervalSec,proto3" json:"pyroscope_upload_interval_sec,omitempty"` + // -- container (200-209) + // Resolve each socket's owning container id from its cgroup v2 id + // (inet_diag_cgroup_id, record field 2003) — sets the record's + // container_id / container_runtime. Set via -resolveContainerId flag or + // CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it and run + // --cgroupns=host in a container). + ResolveContainerId bool `protobuf:"varint,200,opt,name=resolve_container_id,json=resolveContainerId,proto3" json:"resolve_container_id,omitempty"` // Enrich container/netns labels (container_id/name/image/runtime, netns name) // by joining the socket's owning netns inode against the Docker Engine API // index over docker_socket_path. Default false. - EnrichContainerEnable bool `protobuf:"varint,230,opt,name=enrich_container_enable,json=enrichContainerEnable,proto3" json:"enrich_container_enable,omitempty"` + EnrichContainerEnable bool `protobuf:"varint,201,opt,name=enrich_container_enable,json=enrichContainerEnable,proto3" json:"enrich_container_enable,omitempty"` // Docker Engine API unix socket. Default "/run/docker.sock". - DockerSocketPath string `protobuf:"bytes,231,opt,name=docker_socket_path,json=dockerSocketPath,proto3" json:"docker_socket_path,omitempty"` + DockerSocketPath string `protobuf:"bytes,202,opt,name=docker_socket_path,json=dockerSocketPath,proto3" json:"docker_socket_path,omitempty"` + // -- lldp (210-219) // Enrich per-uplink LLDP neighbor labels by reading the lldpd control socket // (lldpd_socket_path) once at startup. Default false. - EnrichLldpEnable bool `protobuf:"varint,232,opt,name=enrich_lldp_enable,json=enrichLldpEnable,proto3" json:"enrich_lldp_enable,omitempty"` + EnrichLldpEnable bool `protobuf:"varint,210,opt,name=enrich_lldp_enable,json=enrichLldpEnable,proto3" json:"enrich_lldp_enable,omitempty"` // lldpd control socket. Default "/run/lldpd.socket". - LldpdSocketPath string `protobuf:"bytes,233,opt,name=lldpd_socket_path,json=lldpdSocketPath,proto3" json:"lldpd_socket_path,omitempty"` + LldpdSocketPath string `protobuf:"bytes,211,opt,name=lldpd_socket_path,json=lldpdSocketPath,proto3" json:"lldpd_socket_path,omitempty"` // Optional lldpd version hint ("1.0.13"/"1.0.18") selecting the struct-layout // descriptor for the wire parser. Empty = auto-detect. Default "". - LldpdVersionHint string `protobuf:"bytes,234,opt,name=lldpd_version_hint,json=lldpdVersionHint,proto3" json:"lldpd_version_hint,omitempty"` + LldpdVersionHint string `protobuf:"bytes,212,opt,name=lldpd_version_hint,json=lldpdVersionHint,proto3" json:"lldpd_version_hint,omitempty"` + // -- nic (220-229) // Enrich per-uplink NIC labels (driver/model/pci/speed/firmware) from sysfs + // the ethtool ioctl once at startup. Default false. - EnrichNicEnable bool `protobuf:"varint,235,opt,name=enrich_nic_enable,json=enrichNicEnable,proto3" json:"enrich_nic_enable,omitempty"` + EnrichNicEnable bool `protobuf:"varint,220,opt,name=enrich_nic_enable,json=enrichNicEnable,proto3" json:"enrich_nic_enable,omitempty"` // Number of host uplink slots to populate (dual-homed hosts = 2). Default 2. - UplinkCount uint32 `protobuf:"varint,236,opt,name=uplink_count,json=uplinkCount,proto3" json:"uplink_count,omitempty"` + UplinkCount uint32 `protobuf:"varint,221,opt,name=uplink_count,json=uplinkCount,proto3" json:"uplink_count,omitempty"` // Explicit uplink interface names, slot order. Empty = auto-detect from the // default IPv4/IPv6 routes. - UplinkInterfaces []string `protobuf:"bytes,237,rep,name=uplink_interfaces,json=uplinkInterfaces,proto3" json:"uplink_interfaces,omitempty"` - // Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for + UplinkInterfaces []string `protobuf:"bytes,222,rep,name=uplink_interfaces,json=uplinkInterfaces,proto3" json:"uplink_interfaces,omitempty"` + // -- nsid (230-239) + // Populate nsid (record field 32) best-effort via RTM_GETNSID. Usually 0 for // Docker/containerd namespaces. Default false. - PopulateNsid bool `protobuf:"varint,238,opt,name=populate_nsid,json=populateNsid,proto3" json:"populate_nsid,omitempty"` - // Enrich the destination IP's ASN (field 1011) and network owner (field - // 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + PopulateNsid bool `protobuf:"varint,230,opt,name=populate_nsid,json=populateNsid,proto3" json:"populate_nsid,omitempty"` + // -- asn (240-244) + // Enrich the destination IP's ASN (record field 320) and network owner + // (322) by longest-prefix-matching it against the ipfeed-collector Parquet // artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when // enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, // and leaves both columns empty. Default false. - EnrichAsnEnable bool `protobuf:"varint,239,opt,name=enrich_asn_enable,json=enrichAsnEnable,proto3" json:"enrich_asn_enable,omitempty"` + EnrichAsnEnable bool `protobuf:"varint,240,opt,name=enrich_asn_enable,json=enrichAsnEnable,proto3" json:"enrich_asn_enable,omitempty"` // Path to the ipfeed-collector Parquet artifact (prefix -> {asn, // network_owner}). Default "". - AsnDbPath string `protobuf:"bytes,240,opt,name=asn_db_path,json=asnDbPath,proto3" json:"asn_db_path,omitempty"` + AsnDbPath string `protobuf:"bytes,241,opt,name=asn_db_path,json=asnDbPath,proto3" json:"asn_db_path,omitempty"` // How often to reload asn_db_path in the background so a refreshed artifact // is picked up without a restart. 0 = load once at startup, never reload. - AsnRefreshInterval *durationpb.Duration `protobuf:"bytes,241,opt,name=asn_refresh_interval,json=asnRefreshInterval,proto3" json:"asn_refresh_interval,omitempty"` - // Classify the destination IP's locality (field 1019) — self / - // connected-subnet / remote — from each monitored network namespace's local - // addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs - // BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: - // a per-namespace discovery failure just leaves that namespace's sockets - // unclassified. Default false. - EnrichLocalityEnable bool `protobuf:"varint,242,opt,name=enrich_locality_enable,json=enrichLocalityEnable,proto3" json:"enrich_locality_enable,omitempty"` + AsnRefreshInterval *durationpb.Duration `protobuf:"bytes,242,opt,name=asn_refresh_interval,json=asnRefreshInterval,proto3" json:"asn_refresh_interval,omitempty"` + // -- locality (245-249) + // Classify the destination IP's locality (record field 310) — self / + // local-subnet / remote — from each monitored network namespace's local + // addresses + routing table, discovered via rtnetlink (pkg/localnet). Also + // yields the egress interface (311/312) and the bound-interface name (300). + // Runs BEFORE the ASN lookup, so self/local-subnet destinations skip it. + // Non-fatal: a per-namespace discovery failure just leaves that namespace's + // sockets unclassified (and is retried with backoff). Default false. + EnrichLocalityEnable bool `protobuf:"varint,245,opt,name=enrich_locality_enable,json=enrichLocalityEnable,proto3" json:"enrich_locality_enable,omitempty"` // How often to re-discover local addresses/routes per namespace so runtime // changes (interfaces up/down, routes added) are picked up. Newly-appeared // namespaces are always snapshotted on the next reconcile regardless. 0 = - // discover once per namespace, never refresh. - LocalityRefreshInterval *durationpb.Duration `protobuf:"bytes,243,opt,name=locality_refresh_interval,json=localityRefreshInterval,proto3" json:"locality_refresh_interval,omitempty"` + // discover once per namespace, never refresh. Daemon default 60s. + LocalityRefreshInterval *durationpb.Duration `protobuf:"bytes,246,opt,name=locality_refresh_interval,json=localityRefreshInterval,proto3" json:"locality_refresh_interval,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1050,6 +1083,13 @@ func (x *XtcpConfig) GetPollTimeout() *durationpb.Duration { return nil } +func (x *XtcpConfig) GetPollJitterPct() uint32 { + if x != nil { + return x.PollJitterPct + } + return 0 +} + func (x *XtcpConfig) GetMaxLoops() uint64 { if x != nil { return x.MaxLoops @@ -1092,20 +1132,6 @@ func (x *XtcpConfig) GetPacketSizeMply() uint32 { return 0 } -func (x *XtcpConfig) GetWriteFiles() uint32 { - if x != nil { - return x.WriteFiles - } - return 0 -} - -func (x *XtcpConfig) GetCapturePath() string { - if x != nil { - return x.CapturePath - } - return "" -} - func (x *XtcpConfig) GetModulus() uint64 { if x != nil { return x.Modulus @@ -1113,317 +1139,324 @@ func (x *XtcpConfig) GetModulus() uint64 { return 0 } -func (x *XtcpConfig) GetMarshalTo() string { +func (x *XtcpConfig) GetEnabledDeserializers() *EnabledDeserializers { if x != nil { - return x.MarshalTo + return x.EnabledDeserializers } - return "" + return nil } -func (x *XtcpConfig) GetEnvelopeFlushThresholdBytes() uint32 { +func (x *XtcpConfig) GetIoUring() bool { if x != nil { - return x.EnvelopeFlushThresholdBytes + return x.IoUring } - return 0 + return false } -func (x *XtcpConfig) GetEnvelopeFlushThresholdRows() uint32 { +func (x *XtcpConfig) GetIoUringRecvBatchSize() uint32 { if x != nil { - return x.EnvelopeFlushThresholdRows + return x.IoUringRecvBatchSize } return 0 } -func (x *XtcpConfig) GetKafkaCompression() string { +func (x *XtcpConfig) GetIoUringCqeBatchSize() uint32 { if x != nil { - return x.KafkaCompression + return x.IoUringCqeBatchSize } - return "" + return 0 } -func (x *XtcpConfig) GetS3Endpoint() string { +func (x *XtcpConfig) GetReconcileFrequency() *durationpb.Duration { if x != nil { - return x.S3Endpoint + return x.ReconcileFrequency } - return "" + return nil } -func (x *XtcpConfig) GetS3Bucket() string { +func (x *XtcpConfig) GetReconcileBeforePoll() bool { if x != nil { - return x.S3Bucket + return x.ReconcileBeforePoll } - return "" + return false } -func (x *XtcpConfig) GetS3Prefix() string { +func (x *XtcpConfig) GetWriteFiles() uint32 { if x != nil { - return x.S3Prefix + return x.WriteFiles } - return "" + return 0 } -func (x *XtcpConfig) GetS3AccessKey() string { +func (x *XtcpConfig) GetCapturePath() string { if x != nil { - return x.S3AccessKey + return x.CapturePath } return "" } -func (x *XtcpConfig) GetS3SecretKey() string { +func (x *XtcpConfig) GetDestWriteFiles() uint32 { if x != nil { - return x.S3SecretKey + return x.DestWriteFiles } - return "" + return 0 } -func (x *XtcpConfig) GetS3ParquetFlushThresholdBytes() uint32 { +func (x *XtcpConfig) GetDebugLevel() uint32 { if x != nil { - return x.S3ParquetFlushThresholdBytes + return x.DebugLevel } return 0 } -func (x *XtcpConfig) GetS3Region() string { +func (x *XtcpConfig) GetDest() string { if x != nil { - return x.S3Region + return x.Dest } return "" } -func (x *XtcpConfig) GetS3SkipBucketProbe() bool { +func (x *XtcpConfig) GetMarshalTo() string { if x != nil { - return x.S3SkipBucketProbe + return x.MarshalTo } - return false + return "" } -func (x *XtcpConfig) GetPyroscopeUrl() string { +func (x *XtcpConfig) GetCsvColumns() string { if x != nil { - return x.PyroscopeUrl + return x.CsvColumns } return "" } -func (x *XtcpConfig) GetPyroscopeAppName() string { +func (x *XtcpConfig) GetXtcpProtoFile() string { if x != nil { - return x.PyroscopeAppName + return x.XtcpProtoFile } return "" } -func (x *XtcpConfig) GetPyroscopeSampleHz() uint32 { +func (x *XtcpConfig) GetEnvelopeFlushThresholdBytes() uint32 { if x != nil { - return x.PyroscopeSampleHz + return x.EnvelopeFlushThresholdBytes } return 0 } -func (x *XtcpConfig) GetPyroscopeUploadIntervalSec() uint32 { +func (x *XtcpConfig) GetEnvelopeFlushThresholdRows() uint32 { if x != nil { - return x.PyroscopeUploadIntervalSec + return x.EnvelopeFlushThresholdRows } return 0 } -func (x *XtcpConfig) GetDest() string { +func (x *XtcpConfig) GetTopic() string { if x != nil { - return x.Dest + return x.Topic } return "" } -func (x *XtcpConfig) GetDestWriteFiles() uint32 { +func (x *XtcpConfig) GetKafkaSchemaUrl() string { if x != nil { - return x.DestWriteFiles + return x.KafkaSchemaUrl } - return 0 + return "" } -func (x *XtcpConfig) GetTopic() string { +func (x *XtcpConfig) GetKafkaProduceTimeout() *durationpb.Duration { if x != nil { - return x.Topic + return x.KafkaProduceTimeout } - return "" + return nil } -func (x *XtcpConfig) GetXtcpProtoFile() string { +func (x *XtcpConfig) GetKafkaCompression() string { if x != nil { - return x.XtcpProtoFile + return x.KafkaCompression } return "" } -func (x *XtcpConfig) GetKafkaSchemaUrl() string { +func (x *XtcpConfig) GetS3Endpoint() string { if x != nil { - return x.KafkaSchemaUrl + return x.S3Endpoint } return "" } -func (x *XtcpConfig) GetKafkaProduceTimeout() *durationpb.Duration { +func (x *XtcpConfig) GetS3Region() string { if x != nil { - return x.KafkaProduceTimeout + return x.S3Region } - return nil + return "" } -func (x *XtcpConfig) GetDebugLevel() uint32 { +func (x *XtcpConfig) GetS3Bucket() string { if x != nil { - return x.DebugLevel + return x.S3Bucket } - return 0 + return "" } -func (x *XtcpConfig) GetLabel() string { +func (x *XtcpConfig) GetS3Prefix() string { if x != nil { - return x.Label + return x.S3Prefix } return "" } -func (x *XtcpConfig) GetTag() string { +func (x *XtcpConfig) GetS3AccessKey() string { if x != nil { - return x.Tag + return x.S3AccessKey } return "" } -func (x *XtcpConfig) GetLocation() string { +func (x *XtcpConfig) GetS3SecretKey() string { if x != nil { - return x.Location + return x.S3SecretKey } return "" } -func (x *XtcpConfig) GetHostname() string { +func (x *XtcpConfig) GetS3SkipBucketProbe() bool { if x != nil { - return x.Hostname + return x.S3SkipBucketProbe } - return "" + return false } -func (x *XtcpConfig) GetDaemonVersion() string { +func (x *XtcpConfig) GetS3ParquetFlushThresholdBytes() uint32 { if x != nil { - return x.DaemonVersion + return x.S3ParquetFlushThresholdBytes } - return "" + return 0 } -func (x *XtcpConfig) GetResolveContainerId() bool { +func (x *XtcpConfig) GetS3FlushInterval() *durationpb.Duration { if x != nil { - return x.ResolveContainerId + return x.S3FlushInterval } - return false + return nil } -func (x *XtcpConfig) GetIpv4Ttl() uint32 { +func (x *XtcpConfig) GetS3FlushJitterPct() uint32 { if x != nil { - return x.Ipv4Ttl + return x.S3FlushJitterPct } return 0 } -func (x *XtcpConfig) GetIpv6HopLimit() uint32 { +func (x *XtcpConfig) GetS3FlushThresholdJitterPct() uint32 { if x != nil { - return x.Ipv6HopLimit + return x.S3FlushThresholdJitterPct } return 0 } -func (x *XtcpConfig) GetGrpcPort() uint32 { +func (x *XtcpConfig) GetS3UploadMaxAttempts() uint32 { if x != nil { - return x.GrpcPort + return x.S3UploadMaxAttempts } return 0 } -func (x *XtcpConfig) GetEnabledDeserializers() *EnabledDeserializers { +func (x *XtcpConfig) GetS3UploadBackoffCap() *durationpb.Duration { if x != nil { - return x.EnabledDeserializers + return x.S3UploadBackoffCap } return nil } -func (x *XtcpConfig) GetIoUring() bool { +func (x *XtcpConfig) GetHostname() string { if x != nil { - return x.IoUring + return x.Hostname } - return false + return "" } -func (x *XtcpConfig) GetIoUringRecvBatchSize() uint32 { +func (x *XtcpConfig) GetLocation() string { if x != nil { - return x.IoUringRecvBatchSize + return x.Location } - return 0 + return "" } -func (x *XtcpConfig) GetIoUringCqeBatchSize() uint32 { +func (x *XtcpConfig) GetLabel() string { if x != nil { - return x.IoUringCqeBatchSize + return x.Label } - return 0 + return "" } -func (x *XtcpConfig) GetCsvColumns() string { +func (x *XtcpConfig) GetTag() string { if x != nil { - return x.CsvColumns + return x.Tag } return "" } -func (x *XtcpConfig) GetPollJitterPct() uint32 { +func (x *XtcpConfig) GetDaemonVersion() string { if x != nil { - return x.PollJitterPct + return x.DaemonVersion } - return 0 + return "" } -func (x *XtcpConfig) GetS3FlushInterval() *durationpb.Duration { +func (x *XtcpConfig) GetIpv4Ttl() uint32 { if x != nil { - return x.S3FlushInterval + return x.Ipv4Ttl } - return nil + return 0 } -func (x *XtcpConfig) GetS3FlushJitterPct() uint32 { +func (x *XtcpConfig) GetIpv6HopLimit() uint32 { if x != nil { - return x.S3FlushJitterPct + return x.Ipv6HopLimit } return 0 } -func (x *XtcpConfig) GetS3FlushThresholdJitterPct() uint32 { +func (x *XtcpConfig) GetGrpcPort() uint32 { if x != nil { - return x.S3FlushThresholdJitterPct + return x.GrpcPort } return 0 } -func (x *XtcpConfig) GetS3UploadMaxAttempts() uint32 { +func (x *XtcpConfig) GetPyroscopeUrl() string { if x != nil { - return x.S3UploadMaxAttempts + return x.PyroscopeUrl } - return 0 + return "" } -func (x *XtcpConfig) GetS3UploadBackoffCap() *durationpb.Duration { +func (x *XtcpConfig) GetPyroscopeAppName() string { if x != nil { - return x.S3UploadBackoffCap + return x.PyroscopeAppName } - return nil + return "" } -func (x *XtcpConfig) GetReconcileFrequency() *durationpb.Duration { +func (x *XtcpConfig) GetPyroscopeSampleHz() uint32 { if x != nil { - return x.ReconcileFrequency + return x.PyroscopeSampleHz } - return nil + return 0 } -func (x *XtcpConfig) GetReconcileBeforePoll() bool { +func (x *XtcpConfig) GetPyroscopeUploadIntervalSec() uint32 { if x != nil { - return x.ReconcileBeforePoll + return x.PyroscopeUploadIntervalSec + } + return 0 +} + +func (x *XtcpConfig) GetResolveContainerId() bool { + if x != nil { + return x.ResolveContainerId } return false } @@ -1614,102 +1647,102 @@ const file_xtcp_config_v1_xtcp_config_proto_rawDesc = "" + "\x1denvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1aenvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n" + "\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n" + "\x18SetEnvelopeFlushResponse\x122\n" + - "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\xae \n" + + "\x06config\x18\x01 \x01(\v2\x1a.xtcp_config.v1.XtcpConfigR\x06config\"\x95 \n" + "\n" + "XtcpConfig\x12F\n" + "\x17nl_timeout_milliseconds\x18\n" + " \x01(\x04B\x0e\xbaH\v\xc8\x01\x012\x06\x18\xa0\x8d\x06(\x00R\x15nlTimeoutMilliseconds\x12S\n" + - "\x0epoll_frequency\x18\x14 \x01(\v2\x19.google.protobuf.DurationB\x11\xbaH\x0e\xc8\x01\x01\xaa\x01\b\"\x04\b\x80\xf5$*\x00R\rpollFrequency\x12O\n" + - "\fpoll_timeout\x18\x1e \x01(\v2\x19.google.protobuf.DurationB\x11\xbaH\x0e\xc8\x01\x01\xaa\x01\b\"\x04\b\x80\xf5$*\x00R\vpollTimeout\x12+\n" + - "\tmax_loops\x18( \x01(\x04B\x0e\xbaH\v\xc8\x01\x002\x06\x18\xa0\x8d\x06(\x00R\bmaxLoops\x12,\n" + + "\x0epoll_frequency\x18\v \x01(\v2\x19.google.protobuf.DurationB\x11\xbaH\x0e\xc8\x01\x01\xaa\x01\b\"\x04\b\x80\xf5$*\x00R\rpollFrequency\x12O\n" + + "\fpoll_timeout\x18\f \x01(\v2\x19.google.protobuf.DurationB\x11\xbaH\x0e\xc8\x01\x01\xaa\x01\b\"\x04\b\x80\xf5$*\x00R\vpollTimeout\x122\n" + + "\x0fpoll_jitter_pct\x18\r \x01(\rB\n" + + "\xbaH\a\xc8\x01\x00*\x02\x18dR\rpollJitterPct\x12+\n" + + "\tmax_loops\x18\x0e \x01(\x04B\x0e\xbaH\v\xc8\x01\x002\x06\x18\xa0\x8d\x06(\x00R\bmaxLoops\x12,\n" + "\n" + - "netlinkers\x182 \x01(\rB\f\xbaH\t\xc8\x01\x01*\x04\x18d(\x01R\n" + + "netlinkers\x18\x0f \x01(\rB\f\xbaH\t\xc8\x01\x01*\x04\x18d(\x01R\n" + "netlinkers\x12H\n" + - "\x19netlinkers_done_chan_size\x183 \x01(\rB\r\xbaH\n" + + "\x19netlinkers_done_chan_size\x18\x10 \x01(\rB\r\xbaH\n" + "\xc8\x01\x01*\x05\x18\xe8\a(\x01R\x16netlinkersDoneChanSize\x12*\n" + - "\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n" + + "\tnlmsg_seq\x18\x11 \x01(\rB\r\xbaH\n" + "\xc8\x01\x01*\x05\x18\x90N(\x00R\bnlmsgSeq\x12/\n" + - "\vpacket_size\x18F \x01(\x04B\x0e\xbaH\v\xc8\x01\x002\x06\x18\xc0\x84=(\x00R\n" + + "\vpacket_size\x18\x12 \x01(\x04B\x0e\xbaH\v\xc8\x01\x002\x06\x18\xc0\x84=(\x00R\n" + "packetSize\x126\n" + - "\x10packet_size_mply\x18P \x01(\rB\f\xbaH\t\xc8\x01\x00*\x04\x18d(\x00R\x0epacketSizeMply\x12.\n" + - "\vwrite_files\x18Z \x01(\rB\r\xbaH\n" + + "\x10packet_size_mply\x18\x13 \x01(\rB\f\xbaH\t\xc8\x01\x00*\x04\x18d(\x00R\x0epacketSizeMply\x12(\n" + + "\amodulus\x18\x14 \x01(\x04B\x0e\xbaH\v\xc8\x01\x012\x06\x18\xc0\x84=(\x01R\amodulus\x12a\n" + + "\x15enabled_deserializers\x18\x15 \x01(\v2$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14enabledDeserializers\x12!\n" + + "\bio_uring\x18\x16 \x01(\bB\x06\xbaH\x03\xc8\x01\x00R\aioUring\x12E\n" + + "\x18io_uring_recv_batch_size\x18\x17 \x01(\rB\r\xbaH\n" + + "\xc8\x01\x00*\x05\x18\x80 (\x01R\x14ioUringRecvBatchSize\x12C\n" + + "\x17io_uring_cqe_batch_size\x18\x18 \x01(\rB\r\xbaH\n" + + "\xc8\x01\x00*\x05\x18\x80 (\x01R\x13ioUringCqeBatchSize\x12W\n" + + "\x13reconcile_frequency\x18( \x01(\v2\x19.google.protobuf.DurationB\v\xbaH\b\xc8\x01\x00\xaa\x01\x022\x00R\x12reconcileFrequency\x122\n" + + "\x15reconcile_before_poll\x18) \x01(\bR\x13reconcileBeforePoll\x12.\n" + + "\vwrite_files\x182 \x01(\rB\r\xbaH\n" + "\xc8\x01\x00*\x05\x18\xe8\a(\x00R\n" + "writeFiles\x12/\n" + - "\fcapture_path\x18d \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18PR\vcapturePath\x12(\n" + - "\amodulus\x18n \x01(\x04B\x0e\xbaH\v\xc8\x01\x012\x06\x18\xc0\x84=(\x01R\amodulus\x12+\n" + - "\n" + - "marshal_to\x18x \x01(\tB\f\xbaH\t\xc8\x01\x01r\x04\x10\x03\x18(R\tmarshalTo\x12K\n" + - "\x1eenvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1benvelopeFlushThresholdBytes\x12I\n" + - "\x1denvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1aenvelopeFlushThresholdRows\x123\n" + - "\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12'\n" + - "\vs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\n" + - "s3Endpoint\x12#\n" + - "\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\bs3Bucket\x12#\n" + - "\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\bs3Prefix\x12+\n" + - "\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\vs3AccessKey\x12+\n" + - "\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\vs3SecretKey\x12O\n" + - " s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n" + - "\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\bs3Region\x128\n" + - "\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\bB\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n" + - "\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\fpyroscopeUrl\x125\n" + - "\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x127\n" + - "\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n" + - "\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n" + - "\x04dest\x18\x82\x01 \x01(\tB\r\xbaH\n" + - "\xc8\x01\x01r\x05\x10\x04\x18\x80\x04R\x04dest\x128\n" + - "\x10dest_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n" + - "\xc8\x01\x00*\x05\x18\xe8\a(\x00R\x0edestWriteFiles\x12#\n" + - "\x05topic\x18\x8c\x01 \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18(R\x05topic\x125\n" + - "\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18PR\rxtcpProtoFile\x127\n" + - "\x10kafka_schema_url\x18\x91\x01 \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\n" + + "csvColumns\x124\n" + + "\x0fxtcp_proto_file\x18? \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18PR\rxtcpProtoFile\x12K\n" + + "\x1eenvelope_flush_threshold_bytes\x18@ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1benvelopeFlushThresholdBytes\x12I\n" + + "\x1denvelope_flush_threshold_rows\x18A \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1aenvelopeFlushThresholdRows\x12\"\n" + + "\x05topic\x18P \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18(R\x05topic\x126\n" + + "\x10kafka_schema_url\x18Q \x01(\tB\f\xbaH\t\xc8\x01\x00r\x04\x10\x01\x18 this.poll_timeout\"\x9f\x01\n" + "\x14EnabledDeserializers\x12K\n" + "\aenabled\x18\x01 \x03(\v21.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\aenabled\x1a:\n" + @@ -1773,11 +1806,11 @@ var file_xtcp_config_v1_xtcp_config_proto_depIdxs = []int32{ 14, // 10: xtcp_config.v1.SetEnvelopeFlushResponse.config:type_name -> xtcp_config.v1.XtcpConfig 17, // 11: xtcp_config.v1.XtcpConfig.poll_frequency:type_name -> google.protobuf.Duration 17, // 12: xtcp_config.v1.XtcpConfig.poll_timeout:type_name -> google.protobuf.Duration - 17, // 13: xtcp_config.v1.XtcpConfig.kafka_produce_timeout:type_name -> google.protobuf.Duration - 15, // 14: xtcp_config.v1.XtcpConfig.enabled_deserializers:type_name -> xtcp_config.v1.EnabledDeserializers - 17, // 15: xtcp_config.v1.XtcpConfig.s3_flush_interval:type_name -> google.protobuf.Duration - 17, // 16: xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap:type_name -> google.protobuf.Duration - 17, // 17: xtcp_config.v1.XtcpConfig.reconcile_frequency:type_name -> google.protobuf.Duration + 15, // 13: xtcp_config.v1.XtcpConfig.enabled_deserializers:type_name -> xtcp_config.v1.EnabledDeserializers + 17, // 14: xtcp_config.v1.XtcpConfig.reconcile_frequency:type_name -> google.protobuf.Duration + 17, // 15: xtcp_config.v1.XtcpConfig.kafka_produce_timeout:type_name -> google.protobuf.Duration + 17, // 16: xtcp_config.v1.XtcpConfig.s3_flush_interval:type_name -> google.protobuf.Duration + 17, // 17: xtcp_config.v1.XtcpConfig.s3_upload_backoff_cap:type_name -> google.protobuf.Duration 17, // 18: xtcp_config.v1.XtcpConfig.asn_refresh_interval:type_name -> google.protobuf.Duration 17, // 19: xtcp_config.v1.XtcpConfig.locality_refresh_interval:type_name -> google.protobuf.Duration 16, // 20: xtcp_config.v1.EnabledDeserializers.enabled:type_name -> xtcp_config.v1.EnabledDeserializers.EnabledEntry diff --git a/gen/go/xtcp_config/xtcp_config_grpc.pb.go b/gen/go/xtcp_config/xtcp_config_grpc.pb.go index 1e568bc..ff39bdd 100644 --- a/gen/go/xtcp_config/xtcp_config_grpc.pb.go +++ b/gen/go/xtcp_config/xtcp_config_grpc.pb.go @@ -1,8 +1,8 @@ // // xTCP - config // -// These are all the structs relating to the TCP diagnotic module in the kernel -// +// Runtime configuration of the xtcp2 daemon, served and mutated over gRPC +// (ConfigService) and mirrored one-to-one by the cmd/xtcp2 CLI flags / env. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder diff --git a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go index ef612a9..7c009fa 100644 --- a/gen/go/xtcp_config/xtcp_config_vtproto.pb.go +++ b/gen/go/xtcp_config/xtcp_config_vtproto.pb.go @@ -669,7 +669,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf i-- - dAtA[i] = 0x9a + dAtA[i] = 0xb2 } if m.EnrichLocalityEnable { i-- @@ -681,7 +681,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf i-- - dAtA[i] = 0x90 + dAtA[i] = 0xa8 } if m.AsnRefreshInterval != nil { size, err := (*durationpb.Duration)(m.AsnRefreshInterval).MarshalToSizedBufferVT(dAtA[:i]) @@ -693,7 +693,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf i-- - dAtA[i] = 0x8a + dAtA[i] = 0x92 } if len(m.AsnDbPath) > 0 { i -= len(m.AsnDbPath) @@ -702,7 +702,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf i-- - dAtA[i] = 0x82 + dAtA[i] = 0x8a } if m.EnrichAsnEnable { i-- @@ -712,9 +712,9 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- - dAtA[i] = 0xe + dAtA[i] = 0xf i-- - dAtA[i] = 0xf8 + dAtA[i] = 0x80 } if m.PopulateNsid { i-- @@ -726,7 +726,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xe i-- - dAtA[i] = 0xf0 + dAtA[i] = 0xb0 } if len(m.UplinkInterfaces) > 0 { for iNdEx := len(m.UplinkInterfaces) - 1; iNdEx >= 0; iNdEx-- { @@ -734,17 +734,17 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.UplinkInterfaces[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UplinkInterfaces[iNdEx]))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xea + dAtA[i] = 0xf2 } } if m.UplinkCount != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.UplinkCount)) i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xe0 + dAtA[i] = 0xe8 } if m.EnrichNicEnable { i-- @@ -754,27 +754,27 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xd8 + dAtA[i] = 0xe0 } if len(m.LldpdVersionHint) > 0 { i -= len(m.LldpdVersionHint) copy(dAtA[i:], m.LldpdVersionHint) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LldpdVersionHint))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xd2 + dAtA[i] = 0xa2 } if len(m.LldpdSocketPath) > 0 { i -= len(m.LldpdSocketPath) copy(dAtA[i:], m.LldpdSocketPath) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LldpdSocketPath))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xca + dAtA[i] = 0x9a } if m.EnrichLldpEnable { i-- @@ -784,18 +784,18 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- - dAtA[i] = 0xe + dAtA[i] = 0xd i-- - dAtA[i] = 0xc0 + dAtA[i] = 0x90 } if len(m.DockerSocketPath) > 0 { i -= len(m.DockerSocketPath) copy(dAtA[i:], m.DockerSocketPath) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DockerSocketPath))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xc i-- - dAtA[i] = 0xba + dAtA[i] = 0xd2 } if m.EnrichContainerEnable { i-- @@ -805,217 +805,246 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- - dAtA[i] = 0xe + dAtA[i] = 0xc i-- - dAtA[i] = 0xb0 + dAtA[i] = 0xc8 } - if m.ReconcileBeforePoll { + if m.ResolveContainerId { i-- - if m.ReconcileBeforePoll { + if m.ResolveContainerId { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- - dAtA[i] = 0xe + dAtA[i] = 0xc i-- - dAtA[i] = 0xa0 + dAtA[i] = 0xc0 } - if m.ReconcileFrequency != nil { - size, err := (*durationpb.Duration)(m.ReconcileFrequency).MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + if m.PyroscopeUploadIntervalSec != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PyroscopeUploadIntervalSec)) i-- - dAtA[i] = 0xe + dAtA[i] = 0xa i-- - dAtA[i] = 0x9a + dAtA[i] = 0xe8 } - if m.S3UploadBackoffCap != nil { - size, err := (*durationpb.Duration)(m.S3UploadBackoffCap).MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + if m.PyroscopeSampleHz != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PyroscopeSampleHz)) i-- - dAtA[i] = 0xe + dAtA[i] = 0xa i-- - dAtA[i] = 0x92 + dAtA[i] = 0xe0 } - if m.S3UploadMaxAttempts != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3UploadMaxAttempts)) + if len(m.PyroscopeAppName) > 0 { + i -= len(m.PyroscopeAppName) + copy(dAtA[i:], m.PyroscopeAppName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PyroscopeAppName))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xa i-- - dAtA[i] = 0x88 + dAtA[i] = 0xda } - if m.S3FlushThresholdJitterPct != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3FlushThresholdJitterPct)) + if len(m.PyroscopeUrl) > 0 { + i -= len(m.PyroscopeUrl) + copy(dAtA[i:], m.PyroscopeUrl) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PyroscopeUrl))) i-- - dAtA[i] = 0xe + dAtA[i] = 0xa i-- - dAtA[i] = 0x80 + dAtA[i] = 0xd2 } - if m.S3FlushJitterPct != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3FlushJitterPct)) + if m.GrpcPort != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GrpcPort)) i-- - dAtA[i] = 0xd + dAtA[i] = 0xa i-- - dAtA[i] = 0xf8 + dAtA[i] = 0x80 } - if m.S3FlushInterval != nil { - size, err := (*durationpb.Duration)(m.S3FlushInterval).MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + if m.Ipv6HopLimit != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ipv6HopLimit)) i-- - dAtA[i] = 0xd + dAtA[i] = 0x9 i-- - dAtA[i] = 0xf2 + dAtA[i] = 0xb8 } - if m.PollJitterPct != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PollJitterPct)) + if m.Ipv4Ttl != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ipv4Ttl)) i-- - dAtA[i] = 0xd + dAtA[i] = 0x9 i-- - dAtA[i] = 0xe8 + dAtA[i] = 0xb0 } - if len(m.CsvColumns) > 0 { - i -= len(m.CsvColumns) - copy(dAtA[i:], m.CsvColumns) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CsvColumns))) + if len(m.DaemonVersion) > 0 { + i -= len(m.DaemonVersion) + copy(dAtA[i:], m.DaemonVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DaemonVersion))) i-- - dAtA[i] = 0xd + dAtA[i] = 0x8 i-- - dAtA[i] = 0xe2 + dAtA[i] = 0xb2 } - if m.IoUringCqeBatchSize != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IoUringCqeBatchSize)) + if len(m.Tag) > 0 { + i -= len(m.Tag) + copy(dAtA[i:], m.Tag) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Tag))) i-- - dAtA[i] = 0xd + dAtA[i] = 0x8 i-- - dAtA[i] = 0xa0 + dAtA[i] = 0xaa } - if m.IoUringRecvBatchSize != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IoUringRecvBatchSize)) + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Label))) i-- - dAtA[i] = 0xd + dAtA[i] = 0x8 i-- - dAtA[i] = 0x98 + dAtA[i] = 0xa2 } - if m.IoUring { + if len(m.Location) > 0 { + i -= len(m.Location) + copy(dAtA[i:], m.Location) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Location))) i-- - if m.IoUring { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } + dAtA[i] = 0x8 i-- - dAtA[i] = 0xd + dAtA[i] = 0x9a + } + if len(m.Hostname) > 0 { + i -= len(m.Hostname) + copy(dAtA[i:], m.Hostname) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname))) i-- - dAtA[i] = 0x90 + dAtA[i] = 0x8 + i-- + dAtA[i] = 0x92 } - if m.EnabledDeserializers != nil { - size, err := m.EnabledDeserializers.MarshalToSizedBufferVT(dAtA[:i]) + if m.S3UploadBackoffCap != nil { + size, err := (*durationpb.Duration)(m.S3UploadBackoffCap).MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0xc + dAtA[i] = 0x7 i-- - dAtA[i] = 0xc2 + dAtA[i] = 0x9a } - if m.GrpcPort != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GrpcPort)) + if m.S3UploadMaxAttempts != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3UploadMaxAttempts)) i-- - dAtA[i] = 0xb + dAtA[i] = 0x7 i-- - dAtA[i] = 0xf0 + dAtA[i] = 0x90 } - if len(m.DaemonVersion) > 0 { - i -= len(m.DaemonVersion) - copy(dAtA[i:], m.DaemonVersion) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DaemonVersion))) + if m.S3FlushThresholdJitterPct != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3FlushThresholdJitterPct)) i-- - dAtA[i] = 0xb + dAtA[i] = 0x7 i-- - dAtA[i] = 0xd2 + dAtA[i] = 0x88 } - if m.Ipv6HopLimit != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ipv6HopLimit)) + if m.S3FlushJitterPct != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3FlushJitterPct)) i-- - dAtA[i] = 0xb + dAtA[i] = 0x7 i-- - dAtA[i] = 0xc8 + dAtA[i] = 0x80 } - if m.Ipv4Ttl != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ipv4Ttl)) + if m.S3FlushInterval != nil { + size, err := (*durationpb.Duration)(m.S3FlushInterval).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0xb + dAtA[i] = 0x6 i-- - dAtA[i] = 0xc0 + dAtA[i] = 0xfa } - if m.ResolveContainerId { + if m.S3ParquetFlushThresholdBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3ParquetFlushThresholdBytes)) i-- - if m.ResolveContainerId { + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xf0 + } + if m.S3SkipBucketProbe { + i-- + if m.S3SkipBucketProbe { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- - dAtA[i] = 0xb + dAtA[i] = 0x6 i-- - dAtA[i] = 0xb8 + dAtA[i] = 0xd0 } - if len(m.Hostname) > 0 { - i -= len(m.Hostname) - copy(dAtA[i:], m.Hostname) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname))) + if len(m.S3SecretKey) > 0 { + i -= len(m.S3SecretKey) + copy(dAtA[i:], m.S3SecretKey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3SecretKey))) i-- - dAtA[i] = 0xb + dAtA[i] = 0x6 i-- - dAtA[i] = 0xb2 + dAtA[i] = 0xca } - if len(m.Location) > 0 { - i -= len(m.Location) - copy(dAtA[i:], m.Location) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Location))) + if len(m.S3AccessKey) > 0 { + i -= len(m.S3AccessKey) + copy(dAtA[i:], m.S3AccessKey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3AccessKey))) i-- - dAtA[i] = 0xb + dAtA[i] = 0x6 i-- - dAtA[i] = 0xaa + dAtA[i] = 0xc2 } - if len(m.Tag) > 0 { - i -= len(m.Tag) - copy(dAtA[i:], m.Tag) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Tag))) + if len(m.S3Prefix) > 0 { + i -= len(m.S3Prefix) + copy(dAtA[i:], m.S3Prefix) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Prefix))) i-- - dAtA[i] = 0xb + dAtA[i] = 0x6 i-- - dAtA[i] = 0xa2 + dAtA[i] = 0xba } - if len(m.Label) > 0 { - i -= len(m.Label) - copy(dAtA[i:], m.Label) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Label))) + if len(m.S3Bucket) > 0 { + i -= len(m.S3Bucket) + copy(dAtA[i:], m.S3Bucket) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Bucket))) i-- - dAtA[i] = 0xa + dAtA[i] = 0x6 i-- - dAtA[i] = 0xd2 + dAtA[i] = 0xb2 } - if m.DebugLevel != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DebugLevel)) + if len(m.S3Region) > 0 { + i -= len(m.S3Region) + copy(dAtA[i:], m.S3Region) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Region))) i-- - dAtA[i] = 0xa + dAtA[i] = 0x6 i-- - dAtA[i] = 0x80 + dAtA[i] = 0xaa + } + if len(m.S3Endpoint) > 0 { + i -= len(m.S3Endpoint) + copy(dAtA[i:], m.S3Endpoint) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Endpoint))) + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0xa2 + } + if len(m.KafkaCompression) > 0 { + i -= len(m.KafkaCompression) + copy(dAtA[i:], m.KafkaCompression) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KafkaCompression))) + i-- + dAtA[i] = 0x5 + i-- + dAtA[i] = 0x9a } if m.KafkaProduceTimeout != nil { size, err := (*durationpb.Duration)(m.KafkaProduceTimeout).MarshalToSizedBufferVT(dAtA[:i]) @@ -1025,254 +1054,219 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x9 + dAtA[i] = 0x5 i-- - dAtA[i] = 0xb2 + dAtA[i] = 0x92 } if len(m.KafkaSchemaUrl) > 0 { i -= len(m.KafkaSchemaUrl) copy(dAtA[i:], m.KafkaSchemaUrl) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KafkaSchemaUrl))) i-- - dAtA[i] = 0x9 + dAtA[i] = 0x5 i-- dAtA[i] = 0x8a } - if len(m.XtcpProtoFile) > 0 { - i -= len(m.XtcpProtoFile) - copy(dAtA[i:], m.XtcpProtoFile) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.XtcpProtoFile))) - i-- - dAtA[i] = 0x8 - i-- - dAtA[i] = 0xfa - } if len(m.Topic) > 0 { i -= len(m.Topic) copy(dAtA[i:], m.Topic) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Topic))) i-- - dAtA[i] = 0x8 - i-- - dAtA[i] = 0xe2 - } - if m.PyroscopeUploadIntervalSec != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PyroscopeUploadIntervalSec)) - i-- - dAtA[i] = 0x8 - i-- - dAtA[i] = 0xd8 - } - if m.PyroscopeSampleHz != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PyroscopeSampleHz)) - i-- - dAtA[i] = 0x8 - i-- - dAtA[i] = 0xd0 - } - if len(m.PyroscopeAppName) > 0 { - i -= len(m.PyroscopeAppName) - copy(dAtA[i:], m.PyroscopeAppName) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PyroscopeAppName))) - i-- - dAtA[i] = 0x8 + dAtA[i] = 0x5 i-- - dAtA[i] = 0xca + dAtA[i] = 0x82 } - if len(m.PyroscopeUrl) > 0 { - i -= len(m.PyroscopeUrl) - copy(dAtA[i:], m.PyroscopeUrl) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PyroscopeUrl))) + if m.EnvelopeFlushThresholdRows != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnvelopeFlushThresholdRows)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x4 i-- - dAtA[i] = 0xc2 + dAtA[i] = 0x88 } - if m.DestWriteFiles != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DestWriteFiles)) + if m.EnvelopeFlushThresholdBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnvelopeFlushThresholdBytes)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x4 i-- - dAtA[i] = 0xb8 + dAtA[i] = 0x80 } - if m.S3SkipBucketProbe { - i-- - if m.S3SkipBucketProbe { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } + if len(m.XtcpProtoFile) > 0 { + i -= len(m.XtcpProtoFile) + copy(dAtA[i:], m.XtcpProtoFile) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.XtcpProtoFile))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0xb0 + dAtA[i] = 0xfa } - if len(m.S3Region) > 0 { - i -= len(m.S3Region) - copy(dAtA[i:], m.S3Region) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Region))) + if len(m.CsvColumns) > 0 { + i -= len(m.CsvColumns) + copy(dAtA[i:], m.CsvColumns) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CsvColumns))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0xaa + dAtA[i] = 0xf2 } - if m.S3ParquetFlushThresholdBytes != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.S3ParquetFlushThresholdBytes)) + if len(m.MarshalTo) > 0 { + i -= len(m.MarshalTo) + copy(dAtA[i:], m.MarshalTo) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MarshalTo))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0xa0 + dAtA[i] = 0xea } if len(m.Dest) > 0 { i -= len(m.Dest) copy(dAtA[i:], m.Dest) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Dest))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0x92 + dAtA[i] = 0xe2 } - if len(m.S3SecretKey) > 0 { - i -= len(m.S3SecretKey) - copy(dAtA[i:], m.S3SecretKey) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3SecretKey))) + if m.DebugLevel != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DebugLevel)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0x8a + dAtA[i] = 0xa8 } - if len(m.S3AccessKey) > 0 { - i -= len(m.S3AccessKey) - copy(dAtA[i:], m.S3AccessKey) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3AccessKey))) + if m.DestWriteFiles != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DestWriteFiles)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x3 i-- - dAtA[i] = 0x82 + dAtA[i] = 0xa0 } - if len(m.S3Prefix) > 0 { - i -= len(m.S3Prefix) - copy(dAtA[i:], m.S3Prefix) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Prefix))) + if len(m.CapturePath) > 0 { + i -= len(m.CapturePath) + copy(dAtA[i:], m.CapturePath) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CapturePath))) i-- - dAtA[i] = 0x7 + dAtA[i] = 0x3 i-- - dAtA[i] = 0xfa + dAtA[i] = 0x9a } - if len(m.S3Bucket) > 0 { - i -= len(m.S3Bucket) - copy(dAtA[i:], m.S3Bucket) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Bucket))) + if m.WriteFiles != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.WriteFiles)) i-- - dAtA[i] = 0x7 + dAtA[i] = 0x3 i-- - dAtA[i] = 0xf2 + dAtA[i] = 0x90 } - if len(m.S3Endpoint) > 0 { - i -= len(m.S3Endpoint) - copy(dAtA[i:], m.S3Endpoint) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S3Endpoint))) - i-- - dAtA[i] = 0x7 + if m.ReconcileBeforePoll { i-- - dAtA[i] = 0xea - } - if len(m.KafkaCompression) > 0 { - i -= len(m.KafkaCompression) - copy(dAtA[i:], m.KafkaCompression) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.KafkaCompression))) + if m.ReconcileBeforePoll { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- - dAtA[i] = 0x7 + dAtA[i] = 0x2 i-- - dAtA[i] = 0xe2 + dAtA[i] = 0xc8 } - if m.EnvelopeFlushThresholdRows != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnvelopeFlushThresholdRows)) + if m.ReconcileFrequency != nil { + size, err := (*durationpb.Duration)(m.ReconcileFrequency).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x7 + dAtA[i] = 0x2 i-- - dAtA[i] = 0xd8 + dAtA[i] = 0xc2 } - if m.EnvelopeFlushThresholdBytes != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnvelopeFlushThresholdBytes)) + if m.IoUringCqeBatchSize != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IoUringCqeBatchSize)) i-- - dAtA[i] = 0x7 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xd0 + dAtA[i] = 0xc0 } - if len(m.MarshalTo) > 0 { - i -= len(m.MarshalTo) - copy(dAtA[i:], m.MarshalTo) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MarshalTo))) + if m.IoUringRecvBatchSize != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IoUringRecvBatchSize)) i-- - dAtA[i] = 0x7 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xc2 + dAtA[i] = 0xb8 } - if m.Modulus != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Modulus)) + if m.IoUring { i-- - dAtA[i] = 0x6 + if m.IoUring { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- - dAtA[i] = 0xf0 + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 } - if len(m.CapturePath) > 0 { - i -= len(m.CapturePath) - copy(dAtA[i:], m.CapturePath) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CapturePath))) + if m.EnabledDeserializers != nil { + size, err := m.EnabledDeserializers.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x6 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xa2 + dAtA[i] = 0xaa } - if m.WriteFiles != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.WriteFiles)) + if m.Modulus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Modulus)) i-- - dAtA[i] = 0x5 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xd0 + dAtA[i] = 0xa0 } if m.PacketSizeMply != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PacketSizeMply)) i-- - dAtA[i] = 0x5 + dAtA[i] = 0x1 i-- - dAtA[i] = 0x80 + dAtA[i] = 0x98 } if m.PacketSize != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PacketSize)) i-- - dAtA[i] = 0x4 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xb0 + dAtA[i] = 0x90 } if m.NlmsgSeq != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NlmsgSeq)) i-- - dAtA[i] = 0x3 + dAtA[i] = 0x1 i-- - dAtA[i] = 0xe0 + dAtA[i] = 0x88 } if m.NetlinkersDoneChanSize != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NetlinkersDoneChanSize)) i-- - dAtA[i] = 0x3 + dAtA[i] = 0x1 i-- - dAtA[i] = 0x98 + dAtA[i] = 0x80 } if m.Netlinkers != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Netlinkers)) i-- - dAtA[i] = 0x3 - i-- - dAtA[i] = 0x90 + dAtA[i] = 0x78 } if m.MaxLoops != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MaxLoops)) i-- - dAtA[i] = 0x2 + dAtA[i] = 0x70 + } + if m.PollJitterPct != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PollJitterPct)) i-- - dAtA[i] = 0xc0 + dAtA[i] = 0x68 } if m.PollTimeout != nil { size, err := (*durationpb.Duration)(m.PollTimeout).MarshalToSizedBufferVT(dAtA[:i]) @@ -1282,9 +1276,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xf2 + dAtA[i] = 0x62 } if m.PollFrequency != nil { size, err := (*durationpb.Duration)(m.PollFrequency).MarshalToSizedBufferVT(dAtA[:i]) @@ -1294,9 +1286,7 @@ func (m *XtcpConfig) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 + dAtA[i] = 0x5a } if m.NlTimeoutMilliseconds != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NlTimeoutMilliseconds)) @@ -1571,17 +1561,20 @@ func (m *XtcpConfig) SizeVT() (n int) { } if m.PollFrequency != nil { l = (*durationpb.Duration)(m.PollFrequency).SizeVT() - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } if m.PollTimeout != nil { l = (*durationpb.Duration)(m.PollTimeout).SizeVT() - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PollJitterPct != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PollJitterPct)) } if m.MaxLoops != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.MaxLoops)) + n += 1 + protohelpers.SizeOfVarint(uint64(m.MaxLoops)) } if m.Netlinkers != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.Netlinkers)) + n += 1 + protohelpers.SizeOfVarint(uint64(m.Netlinkers)) } if m.NetlinkersDoneChanSize != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.NetlinkersDoneChanSize)) @@ -1595,89 +1588,68 @@ func (m *XtcpConfig) SizeVT() (n int) { if m.PacketSizeMply != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.PacketSizeMply)) } - if m.WriteFiles != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.WriteFiles)) - } - l = len(m.CapturePath) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) - } if m.Modulus != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.Modulus)) } - l = len(m.MarshalTo) - if l > 0 { + if m.EnabledDeserializers != nil { + l = m.EnabledDeserializers.SizeVT() n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.EnvelopeFlushThresholdBytes != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.EnvelopeFlushThresholdBytes)) + if m.IoUring { + n += 3 } - if m.EnvelopeFlushThresholdRows != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.EnvelopeFlushThresholdRows)) + if m.IoUringRecvBatchSize != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.IoUringRecvBatchSize)) } - l = len(m.KafkaCompression) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + if m.IoUringCqeBatchSize != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.IoUringCqeBatchSize)) } - l = len(m.S3Endpoint) - if l > 0 { + if m.ReconcileFrequency != nil { + l = (*durationpb.Duration)(m.ReconcileFrequency).SizeVT() n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.S3Bucket) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + if m.ReconcileBeforePoll { + n += 3 } - l = len(m.S3Prefix) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + if m.WriteFiles != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.WriteFiles)) } - l = len(m.S3AccessKey) + l = len(m.CapturePath) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.S3SecretKey) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + if m.DestWriteFiles != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.DestWriteFiles)) + } + if m.DebugLevel != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.DebugLevel)) } l = len(m.Dest) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.S3ParquetFlushThresholdBytes != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.S3ParquetFlushThresholdBytes)) - } - l = len(m.S3Region) + l = len(m.MarshalTo) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.S3SkipBucketProbe { - n += 3 - } - if m.DestWriteFiles != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.DestWriteFiles)) - } - l = len(m.PyroscopeUrl) + l = len(m.CsvColumns) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.PyroscopeAppName) + l = len(m.XtcpProtoFile) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.PyroscopeSampleHz != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.PyroscopeSampleHz)) + if m.EnvelopeFlushThresholdBytes != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnvelopeFlushThresholdBytes)) } - if m.PyroscopeUploadIntervalSec != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.PyroscopeUploadIntervalSec)) + if m.EnvelopeFlushThresholdRows != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnvelopeFlushThresholdRows)) } l = len(m.Topic) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.XtcpProtoFile) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) - } l = len(m.KafkaSchemaUrl) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) @@ -1686,60 +1658,39 @@ func (m *XtcpConfig) SizeVT() (n int) { l = (*durationpb.Duration)(m.KafkaProduceTimeout).SizeVT() n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.DebugLevel != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.DebugLevel)) - } - l = len(m.Label) + l = len(m.KafkaCompression) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.Tag) + l = len(m.S3Endpoint) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.Location) + l = len(m.S3Region) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.Hostname) + l = len(m.S3Bucket) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.ResolveContainerId { - n += 3 - } - if m.Ipv4Ttl != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.Ipv4Ttl)) - } - if m.Ipv6HopLimit != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.Ipv6HopLimit)) - } - l = len(m.DaemonVersion) + l = len(m.S3Prefix) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.GrpcPort != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.GrpcPort)) - } - if m.EnabledDeserializers != nil { - l = m.EnabledDeserializers.SizeVT() + l = len(m.S3AccessKey) + if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.IoUring { - n += 3 - } - if m.IoUringRecvBatchSize != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.IoUringRecvBatchSize)) - } - if m.IoUringCqeBatchSize != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.IoUringCqeBatchSize)) - } - l = len(m.CsvColumns) + l = len(m.S3SecretKey) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.PollJitterPct != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.PollJitterPct)) + if m.S3SkipBucketProbe { + n += 3 + } + if m.S3ParquetFlushThresholdBytes != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.S3ParquetFlushThresholdBytes)) } if m.S3FlushInterval != nil { l = (*durationpb.Duration)(m.S3FlushInterval).SizeVT() @@ -1758,11 +1709,50 @@ func (m *XtcpConfig) SizeVT() (n int) { l = (*durationpb.Duration)(m.S3UploadBackoffCap).SizeVT() n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.ReconcileFrequency != nil { - l = (*durationpb.Duration)(m.ReconcileFrequency).SizeVT() + l = len(m.Hostname) + if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.ReconcileBeforePoll { + l = len(m.Location) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Label) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Tag) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.DaemonVersion) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Ipv4Ttl != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.Ipv4Ttl)) + } + if m.Ipv6HopLimit != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.Ipv6HopLimit)) + } + if m.GrpcPort != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.GrpcPort)) + } + l = len(m.PyroscopeUrl) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.PyroscopeAppName) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PyroscopeSampleHz != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.PyroscopeSampleHz)) + } + if m.PyroscopeUploadIntervalSec != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.PyroscopeUploadIntervalSec)) + } + if m.ResolveContainerId { n += 3 } if m.EnrichContainerEnable { @@ -3091,7 +3081,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 20: + case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PollFrequency", wireType) } @@ -3127,7 +3117,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex - case 30: + case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PollTimeout", wireType) } @@ -3163,7 +3153,26 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex - case 40: + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PollJitterPct", wireType) + } + m.PollJitterPct = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PollJitterPct |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxLoops", wireType) } @@ -3182,7 +3191,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 50: + case 15: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Netlinkers", wireType) } @@ -3201,7 +3210,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 51: + case 16: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NetlinkersDoneChanSize", wireType) } @@ -3220,7 +3229,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 60: + case 17: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NlmsgSeq", wireType) } @@ -3239,7 +3248,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 70: + case 18: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PacketSize", wireType) } @@ -3258,7 +3267,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 80: + case 19: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PacketSizeMply", wireType) } @@ -3277,11 +3286,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 90: + case 20: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field WriteFiles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Modulus", wireType) } - m.WriteFiles = 0 + m.Modulus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3291,16 +3300,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.WriteFiles |= uint32(b&0x7F) << shift + m.Modulus |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 100: + case 21: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CapturePath", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EnabledDeserializers", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3310,29 +3319,33 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.CapturePath = string(dAtA[iNdEx:postIndex]) + if m.EnabledDeserializers == nil { + m.EnabledDeserializers = &EnabledDeserializers{} + } + if err := m.EnabledDeserializers.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 110: + case 22: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Modulus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IoUring", wireType) } - m.Modulus = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3342,16 +3355,17 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Modulus |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 120: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MarshalTo", wireType) + m.IoUring = bool(v != 0) + case 23: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IoUringRecvBatchSize", wireType) } - var stringLen uint64 + m.IoUringRecvBatchSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3361,29 +3375,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.IoUringRecvBatchSize |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.MarshalTo = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 122: + case 24: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EnvelopeFlushThresholdBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IoUringCqeBatchSize", wireType) } - m.EnvelopeFlushThresholdBytes = 0 + m.IoUringCqeBatchSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3393,16 +3394,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EnvelopeFlushThresholdBytes |= uint32(b&0x7F) << shift + m.IoUringCqeBatchSize |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 123: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EnvelopeFlushThresholdRows", wireType) + case 40: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReconcileFrequency", wireType) } - m.EnvelopeFlushThresholdRows = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3412,16 +3413,33 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EnvelopeFlushThresholdRows |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 124: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KafkaCompression", wireType) + if msglen < 0 { + return protohelpers.ErrInvalidLength } - var stringLen uint64 + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReconcileFrequency == nil { + m.ReconcileFrequency = &durationpb1.Duration{} + } + if err := (*durationpb.Duration)(m.ReconcileFrequency).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 41: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReconcileBeforePoll", wireType) + } + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3431,29 +3449,17 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.KafkaCompression = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 125: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3Endpoint", wireType) + m.ReconcileBeforePoll = bool(v != 0) + case 50: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WriteFiles", wireType) } - var stringLen uint64 + m.WriteFiles = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3463,27 +3469,14 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.WriteFiles |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.S3Endpoint = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 126: + case 51: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3Bucket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CapturePath", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3511,13 +3504,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.S3Bucket = string(dAtA[iNdEx:postIndex]) + m.CapturePath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 127: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3Prefix", wireType) + case 52: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DestWriteFiles", wireType) } - var stringLen uint64 + m.DestWriteFiles = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3527,27 +3520,33 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.DestWriteFiles |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength + case 53: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugLevel", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.DebugLevel = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebugLevel |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - m.S3Prefix = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 128: + case 60: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3AccessKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3575,11 +3574,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.S3AccessKey = string(dAtA[iNdEx:postIndex]) + m.Dest = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 129: + case 61: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3SecretKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MarshalTo", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3607,11 +3606,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.S3SecretKey = string(dAtA[iNdEx:postIndex]) + m.MarshalTo = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 130: + case 62: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CsvColumns", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3639,30 +3638,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Dest = string(dAtA[iNdEx:postIndex]) + m.CsvColumns = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 132: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field S3ParquetFlushThresholdBytes", wireType) - } - m.S3ParquetFlushThresholdBytes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.S3ParquetFlushThresholdBytes |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 133: + case 63: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field XtcpProtoFile", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3690,13 +3670,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.S3Region = string(dAtA[iNdEx:postIndex]) + m.XtcpProtoFile = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 134: + case 64: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field S3SkipBucketProbe", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EnvelopeFlushThresholdBytes", wireType) } - var v int + m.EnvelopeFlushThresholdBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3706,17 +3686,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.EnvelopeFlushThresholdBytes |= uint32(b&0x7F) << shift if b < 0x80 { break } } - m.S3SkipBucketProbe = bool(v != 0) - case 135: + case 65: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DestWriteFiles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EnvelopeFlushThresholdRows", wireType) } - m.DestWriteFiles = 0 + m.EnvelopeFlushThresholdRows = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3726,14 +3705,14 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DestWriteFiles |= uint32(b&0x7F) << shift + m.EnvelopeFlushThresholdRows |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 136: + case 80: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeUrl", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3761,11 +3740,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PyroscopeUrl = string(dAtA[iNdEx:postIndex]) + m.Topic = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 137: + case 81: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeAppName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KafkaSchemaUrl", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3793,13 +3772,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PyroscopeAppName = string(dAtA[iNdEx:postIndex]) + m.KafkaSchemaUrl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 138: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeSampleHz", wireType) + case 82: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KafkaProduceTimeout", wireType) } - m.PyroscopeSampleHz = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3809,33 +3788,31 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PyroscopeSampleHz |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 139: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeUploadIntervalSec", wireType) + if msglen < 0 { + return protohelpers.ErrInvalidLength } - m.PyroscopeUploadIntervalSec = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PyroscopeUploadIntervalSec |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.KafkaProduceTimeout == nil { + m.KafkaProduceTimeout = &durationpb1.Duration{} + } + if err := (*durationpb.Duration)(m.KafkaProduceTimeout).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err } - case 140: + iNdEx = postIndex + case 83: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KafkaCompression", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3863,11 +3840,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Topic = string(dAtA[iNdEx:postIndex]) + m.KafkaCompression = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 143: + case 100: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field XtcpProtoFile", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3895,11 +3872,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.XtcpProtoFile = string(dAtA[iNdEx:postIndex]) + m.S3Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 145: + case 101: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KafkaSchemaUrl", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -3927,13 +3904,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.KafkaSchemaUrl = string(dAtA[iNdEx:postIndex]) + m.S3Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 150: + case 102: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KafkaProduceTimeout", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3Bucket", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3943,50 +3920,27 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - if m.KafkaProduceTimeout == nil { - m.KafkaProduceTimeout = &durationpb1.Duration{} - } - if err := (*durationpb.Duration)(m.KafkaProduceTimeout).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.S3Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 160: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebugLevel", wireType) - } - m.DebugLevel = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebugLevel |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 170: + case 103: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4014,11 +3968,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Label = string(dAtA[iNdEx:postIndex]) + m.S3Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 180: + case 104: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3AccessKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4046,11 +4000,11 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Tag = string(dAtA[iNdEx:postIndex]) + m.S3AccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 181: + case 105: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3SecretKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4078,13 +4032,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Location = string(dAtA[iNdEx:postIndex]) + m.S3SecretKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 182: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + case 106: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field S3SkipBucketProbe", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4094,29 +4048,17 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Hostname = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 183: + m.S3SkipBucketProbe = bool(v != 0) + case 110: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ResolveContainerId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3ParquetFlushThresholdBytes", wireType) } - var v int + m.S3ParquetFlushThresholdBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4126,17 +4068,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.S3ParquetFlushThresholdBytes |= uint32(b&0x7F) << shift if b < 0x80 { break } } - m.ResolveContainerId = bool(v != 0) - case 184: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Ttl", wireType) + case 111: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field S3FlushInterval", wireType) } - m.Ipv4Ttl = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4146,16 +4087,33 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Ipv4Ttl |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 185: + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.S3FlushInterval == nil { + m.S3FlushInterval = &durationpb1.Duration{} + } + if err := (*durationpb.Duration)(m.S3FlushInterval).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 112: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Ipv6HopLimit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3FlushJitterPct", wireType) } - m.Ipv6HopLimit = 0 + m.S3FlushJitterPct = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4165,16 +4123,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Ipv6HopLimit |= uint32(b&0x7F) << shift + m.S3FlushJitterPct |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 186: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DaemonVersion", wireType) + case 113: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field S3FlushThresholdJitterPct", wireType) } - var stringLen uint64 + m.S3FlushThresholdJitterPct = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4184,29 +4142,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.S3FlushThresholdJitterPct |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.DaemonVersion = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 190: + case 114: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GrpcPort", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3UploadMaxAttempts", wireType) } - m.GrpcPort = 0 + m.S3UploadMaxAttempts = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4216,14 +4161,14 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.GrpcPort |= uint32(b&0x7F) << shift + m.S3UploadMaxAttempts |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 200: + case 115: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EnabledDeserializers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field S3UploadBackoffCap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4250,18 +4195,18 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.EnabledDeserializers == nil { - m.EnabledDeserializers = &EnabledDeserializers{} + if m.S3UploadBackoffCap == nil { + m.S3UploadBackoffCap = &durationpb1.Duration{} } - if err := m.EnabledDeserializers.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := (*durationpb.Duration)(m.S3UploadBackoffCap).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 210: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IoUring", wireType) + case 130: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4271,36 +4216,29 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.IoUring = bool(v != 0) - case 211: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IoUringRecvBatchSize", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength } - m.IoUringRecvBatchSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.IoUringRecvBatchSize |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength } - case 212: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IoUringCqeBatchSize", wireType) + if postIndex > l { + return io.ErrUnexpectedEOF } - m.IoUringCqeBatchSize = 0 + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 131: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4310,14 +4248,27 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.IoUringCqeBatchSize |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 220: + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Location = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 132: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CsvColumns", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4345,13 +4296,13 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CsvColumns = string(dAtA[iNdEx:postIndex]) + m.Label = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 221: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PollJitterPct", wireType) + case 133: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType) } - m.PollJitterPct = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4361,16 +4312,29 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PollJitterPct |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 222: + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tag = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 134: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3FlushInterval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DaemonVersion", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4380,33 +4344,29 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - if m.S3FlushInterval == nil { - m.S3FlushInterval = &durationpb1.Duration{} - } - if err := (*durationpb.Duration)(m.S3FlushInterval).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.DaemonVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 223: + case 150: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field S3FlushJitterPct", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Ttl", wireType) } - m.S3FlushJitterPct = 0 + m.Ipv4Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4416,16 +4376,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.S3FlushJitterPct |= uint32(b&0x7F) << shift + m.Ipv4Ttl |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 224: + case 151: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field S3FlushThresholdJitterPct", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ipv6HopLimit", wireType) } - m.S3FlushThresholdJitterPct = 0 + m.Ipv6HopLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4435,16 +4395,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.S3FlushThresholdJitterPct |= uint32(b&0x7F) << shift + m.Ipv6HopLimit |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 225: + case 160: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field S3UploadMaxAttempts", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GrpcPort", wireType) } - m.S3UploadMaxAttempts = 0 + m.GrpcPort = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4454,16 +4414,16 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.S3UploadMaxAttempts |= uint32(b&0x7F) << shift + m.GrpcPort |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 226: + case 170: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3UploadBackoffCap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeUrl", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4473,33 +4433,29 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - if m.S3UploadBackoffCap == nil { - m.S3UploadBackoffCap = &durationpb1.Duration{} - } - if err := (*durationpb.Duration)(m.S3UploadBackoffCap).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.PyroscopeUrl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 227: + case 171: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReconcileFrequency", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeAppName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4509,31 +4465,65 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReconcileFrequency == nil { - m.ReconcileFrequency = &durationpb1.Duration{} + m.PyroscopeAppName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 172: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeSampleHz", wireType) } - if err := (*durationpb.Duration)(m.ReconcileFrequency).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err + m.PyroscopeSampleHz = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PyroscopeSampleHz |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 228: + case 173: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReconcileBeforePoll", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PyroscopeUploadIntervalSec", wireType) + } + m.PyroscopeUploadIntervalSec = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PyroscopeUploadIntervalSec |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 200: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResolveContainerId", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -4550,8 +4540,8 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - m.ReconcileBeforePoll = bool(v != 0) - case 230: + m.ResolveContainerId = bool(v != 0) + case 201: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EnrichContainerEnable", wireType) } @@ -4571,7 +4561,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.EnrichContainerEnable = bool(v != 0) - case 231: + case 202: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DockerSocketPath", wireType) } @@ -4603,7 +4593,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } m.DockerSocketPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 232: + case 210: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EnrichLldpEnable", wireType) } @@ -4623,7 +4613,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.EnrichLldpEnable = bool(v != 0) - case 233: + case 211: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LldpdSocketPath", wireType) } @@ -4655,7 +4645,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } m.LldpdSocketPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 234: + case 212: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LldpdVersionHint", wireType) } @@ -4687,7 +4677,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } m.LldpdVersionHint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 235: + case 220: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EnrichNicEnable", wireType) } @@ -4707,7 +4697,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.EnrichNicEnable = bool(v != 0) - case 236: + case 221: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UplinkCount", wireType) } @@ -4726,7 +4716,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { break } } - case 237: + case 222: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UplinkInterfaces", wireType) } @@ -4758,7 +4748,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } m.UplinkInterfaces = append(m.UplinkInterfaces, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 238: + case 230: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PopulateNsid", wireType) } @@ -4778,7 +4768,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.PopulateNsid = bool(v != 0) - case 239: + case 240: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EnrichAsnEnable", wireType) } @@ -4798,7 +4788,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.EnrichAsnEnable = bool(v != 0) - case 240: + case 241: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AsnDbPath", wireType) } @@ -4830,7 +4820,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } m.AsnDbPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 241: + case 242: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AsnRefreshInterval", wireType) } @@ -4866,7 +4856,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex - case 242: + case 245: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EnrichLocalityEnable", wireType) } @@ -4886,7 +4876,7 @@ func (m *XtcpConfig) UnmarshalVT(dAtA []byte) error { } } m.EnrichLocalityEnable = bool(v != 0) - case 243: + case 246: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LocalityRefreshInterval", wireType) } diff --git a/gen/go/xtcp_flat_record/vtproto_conformance_test.go b/gen/go/xtcp_flat_record/vtproto_conformance_test.go index 98f1d4b..cf2834b 100644 --- a/gen/go/xtcp_flat_record/vtproto_conformance_test.go +++ b/gen/go/xtcp_flat_record/vtproto_conformance_test.go @@ -168,7 +168,7 @@ func TestVTProtoConformance_XtcpFlatRecord_fixtures(t *testing.T) { cases := map[string]*XtcpFlatRecord{ "empty": {}, "minimal": {Hostname: "h", InetDiagMsgState: 1, - CongestionAlgorithmEnum: XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC}, + InetDiagCongEnum: XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC}, "ipv4": {InetDiagMsgFamily: 2, InetDiagMsgSocketSource: []byte{10, 0, 0, 5}, InetDiagMsgSocketSourcePort: 443}, "ipv6": {InetDiagMsgFamily: 10, diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go index 96170b6..164d26a 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record.pb.go @@ -1,20 +1,52 @@ // // xTCP - eXport TCP Inet Diagnostic messages // -// These are all the structs relating to the TCP diagnotic module in the kernel +// XtcpFlatRecord is one flat row per socket: daemon metadata, daemon-computed +// enrichment, and the raw kernel inet_diag payload (struct inet_diag_msg + every +// INET_DIAG_* extension xtcp requests). Protobuf's smallest scalar is 32 bits, +// so kernel __u8/__u16 members are widened to uint32; the trailing comment on +// every payload field records the kernel member and its C type. // -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 +// Kernel source of truth (Linux 7.2-rc, include/uapi/linux/): +// inet_diag.h struct inet_diag_msg, inet_diag_sockid, inet_diag_meminfo, +// tcpvegas_info, tcp_dctcp_info, tcp_bbr_info, inet_diag_sockopt, +// enum INET_DIAG_* (extension attribute ids) +// tcp.h struct tcp_info +// sock_diag.h enum SK_MEMINFO_* +// net/ipv4/inet_diag.c inet_sk_diag_fill / inet_diag_msg_attrs_fill (what +// each nla_put_* actually carries) // -// There are links to the kernel source showing where the struct came from. +// --------------------------------------------------------------------------- +// FIELD-NUMBER ALLOCATION POLICY (v2, 2026-09) +// --------------------------------------------------------------------------- +// 1-299 metadata daemon identity, time, namespace, container, labels, +// bookkeeping, per-uplink host topology (one block each) +// 300-399 enrichment daemon-COMPUTED fields (NOT read from the kernel): +// 300-309 socket-side, 310-349 destination-side, +// 350-389 source-side (future), 390-399 spare +// 400-999 spare unallocated; open a new metadata/enrichment block here +// 1000+ payload raw kernel inet_diag data, ONE hundred-block per kernel +// struct / INET_DIAG_* extension (1000 inet_diag_msg, +// 1100 meminfo, 1200 tcp_info, 1300 cong, 1400 tos/tclass, +// 1500 skmeminfo, 1600 shutdown, 1700 vegas, 1800 dctcp, +// 1900 bbr, 2000 class_id/sockopt/cgroup_id; next free +// block = 2100) +// Wire cost: tags 1-15 = 1 byte, 16-2047 = 2 bytes, 2048+ = 3 bytes. Every field +// here is <= 2047. Fill free slots inside an existing block before opening one +// above 2047. +// Naming: payload fields are _ using the kernel's +// exact spelling (tcp_info_rttvar, not rtt_var). Attributes with no struct take +// the lowercased INET_DIAG_* name (inet_diag_tos). The six inet_diag_msg_socket_* +// sockid fields keep their descriptive names (heavily used downstream). +// Evolution: never reuse a number or a name (add both to `reserved`); any rename +// or renumber is a new record epoch -> bump XtcpFlatRecordSchemaVersion +// (pkg/xtcp/schema_version.go) and add the matching ClickHouse _vN table + MV +// (build/containers/clickhouse/initdb.d/sql/). Adding a field in a free slot is +// NOT an epoch bump. ClickHouse maps columns by field NAME; Parquet by NAME; +// the csv/tsv marshallers by DECLARATION ORDER; gRPC clients are built from +// gen/go in this repo. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder - -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto - // https://protobuf.dev/programming-guides/encoding/#structure // Code generated by protoc-gen-go. DO NOT EDIT. @@ -40,13 +72,13 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +// ---- enrichment: destination-side (310-349) ------------------------------ // Destination endpoint locality, classified from the socket's own network // namespace's local addresses + routing table (discovered via rtnetlink, -// see pkg/localnet). Populated by the opt-in locality enricher BEFORE the -// ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, -// so dest_asn (1011) / dest_network_owner (1018) stay empty for them. -// UNSPECIFIED when locality enrichment is disabled or the namespace has no -// snapshot yet. +// see pkg/localnet). Computed BEFORE the ASN lookup: SELF and LOCAL_SUBNET +// destinations never reach the ASN feed, so enrich_socket_dest_asn (320) / +// enrich_socket_dest_network_owner (322) stay empty for them. UNSPECIFIED +// when locality enrichment is disabled or the namespace has no snapshot yet. type XtcpFlatRecord_Locality int32 const ( @@ -209,28 +241,23 @@ func (x *Envelope) GetRow() []*XtcpFlatRecord { return nil } -// Field-number layout (reorganised 2026-08 while the record had few consumers): -// -// metadata ... 1-999 (identity + per-uplink network topology) -// payload ... 1000+ (kernel inet_diag subsystems, one hundred-block each) -// -// ClickHouse's Protobuf format maps columns by field NAME and Parquet uses its own -// schema, so the wire-tag renumber does not break ingestion or historical Parquet. +// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information type XtcpFlatRecord struct { state protoimpl.MessageState `protogen:"open.v1"` // ---- metadata: record format provenance (1-2) ---------------------------- // Record format epoch. Stamped unconditionally into every record so consumers // can route records to per-version tables and migrate/aggregate across them. - // 0 = pre-versioning daemons (this field absent on the wire → proto3 zero - // default), which acts as the "legacy" bucket. Bump the daemon-side constant - // (XtcpFlatRecordSchemaVersion) whenever the format changes meaningfully. + // 0 = pre-versioning daemons (this field absent on the wire -> proto3 zero + // default), which acts as the "legacy" bucket. 1 = 2026-08/09 layout. + // 2 = this layout (kernel-spelled payload names, enrichment regroup). Bump the + // daemon-side constant (XtcpFlatRecordSchemaVersion) on any rename/renumber. SchemaVersion uint32 `protobuf:"varint,1,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"` // Daemon build provenance (git commit / build date / version, from -ldflags). // Informational only — for debugging which binary produced a row; NOT used for // routing (that is schema_version). Empty when built without ldflags. DaemonVersion string `protobuf:"bytes,2,opt,name=daemon_version,json=daemonVersion,proto3" json:"daemon_version,omitempty"` // ---- metadata: time (10) ------------------------------------------------- - TimestampNs int64 `protobuf:"varint,10,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"` + TimestampNs int64 `protobuf:"varint,10,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"` // time.Now().UnixNano() at record build // ---- metadata: host identity (20s) --------------------------------------- Hostname string `protobuf:"bytes,20,opt,name=hostname,proto3" json:"hostname,omitempty"` // Deployment grouping / facility this daemon runs in — generic across @@ -279,7 +306,8 @@ type XtcpFlatRecord struct { // Static per boot; captured once at startup (best-effort). Hosts are // dual-homed, so there are two fixed uplink slots. All values repeat on every // record and dictionary-compress to ~nothing. NIC info: sysfs + ethtool - // ioctl. LLDP: lldpd control socket (/run/lldpd.socket). + // ioctl (100-107, free 108-119). LLDP: lldpd control socket + // (/run/lldpd.socket) (120-124, free 125-199). Uplink1Ifname string `protobuf:"bytes,100,opt,name=uplink1_ifname,json=uplink1Ifname,proto3" json:"uplink1_ifname,omitempty"` Uplink1NicDriver string `protobuf:"bytes,101,opt,name=uplink1_nic_driver,json=uplink1NicDriver,proto3" json:"uplink1_nic_driver,omitempty"` Uplink1NicModel string `protobuf:"bytes,102,opt,name=uplink1_nic_model,json=uplink1NicModel,proto3" json:"uplink1_nic_model,omitempty"` @@ -294,42 +322,62 @@ type XtcpFlatRecord struct { Uplink1LldpPortId string `protobuf:"bytes,123,opt,name=uplink1_lldp_port_id,json=uplink1LldpPortId,proto3" json:"uplink1_lldp_port_id,omitempty"` Uplink1LldpPortDescr string `protobuf:"bytes,124,opt,name=uplink1_lldp_port_descr,json=uplink1LldpPortDescr,proto3" json:"uplink1_lldp_port_descr,omitempty"` // ---- metadata: host network topology, uplink slot 2 (200s) --------------- - Uplink2Ifname string `protobuf:"bytes,200,opt,name=uplink2_ifname,json=uplink2Ifname,proto3" json:"uplink2_ifname,omitempty"` - Uplink2NicDriver string `protobuf:"bytes,201,opt,name=uplink2_nic_driver,json=uplink2NicDriver,proto3" json:"uplink2_nic_driver,omitempty"` - Uplink2NicModel string `protobuf:"bytes,202,opt,name=uplink2_nic_model,json=uplink2NicModel,proto3" json:"uplink2_nic_model,omitempty"` - Uplink2NicPciVendor uint32 `protobuf:"varint,203,opt,name=uplink2_nic_pci_vendor,json=uplink2NicPciVendor,proto3" json:"uplink2_nic_pci_vendor,omitempty"` - Uplink2NicPciDevice uint32 `protobuf:"varint,204,opt,name=uplink2_nic_pci_device,json=uplink2NicPciDevice,proto3" json:"uplink2_nic_pci_device,omitempty"` - Uplink2NicBusInfo string `protobuf:"bytes,205,opt,name=uplink2_nic_bus_info,json=uplink2NicBusInfo,proto3" json:"uplink2_nic_bus_info,omitempty"` - Uplink2NicSpeedMbps uint32 `protobuf:"varint,206,opt,name=uplink2_nic_speed_mbps,json=uplink2NicSpeedMbps,proto3" json:"uplink2_nic_speed_mbps,omitempty"` - Uplink2NicFwVersion string `protobuf:"bytes,207,opt,name=uplink2_nic_fw_version,json=uplink2NicFwVersion,proto3" json:"uplink2_nic_fw_version,omitempty"` - Uplink2LldpChassisName string `protobuf:"bytes,220,opt,name=uplink2_lldp_chassis_name,json=uplink2LldpChassisName,proto3" json:"uplink2_lldp_chassis_name,omitempty"` - Uplink2LldpChassisId string `protobuf:"bytes,221,opt,name=uplink2_lldp_chassis_id,json=uplink2LldpChassisId,proto3" json:"uplink2_lldp_chassis_id,omitempty"` - Uplink2LldpMgmtIp string `protobuf:"bytes,222,opt,name=uplink2_lldp_mgmt_ip,json=uplink2LldpMgmtIp,proto3" json:"uplink2_lldp_mgmt_ip,omitempty"` - Uplink2LldpPortId string `protobuf:"bytes,223,opt,name=uplink2_lldp_port_id,json=uplink2LldpPortId,proto3" json:"uplink2_lldp_port_id,omitempty"` - Uplink2LldpPortDescr string `protobuf:"bytes,224,opt,name=uplink2_lldp_port_descr,json=uplink2LldpPortDescr,proto3" json:"uplink2_lldp_port_descr,omitempty"` - InetDiagMsgFamily uint32 `protobuf:"varint,1001,opt,name=inet_diag_msg_family,json=inetDiagMsgFamily,proto3" json:"inet_diag_msg_family,omitempty"` // uint8 - InetDiagMsgState uint32 `protobuf:"varint,1002,opt,name=inet_diag_msg_state,json=inetDiagMsgState,proto3" json:"inet_diag_msg_state,omitempty"` // uint8 - InetDiagMsgTimer uint32 `protobuf:"varint,1003,opt,name=inet_diag_msg_timer,json=inetDiagMsgTimer,proto3" json:"inet_diag_msg_timer,omitempty"` // uint8 - InetDiagMsgRetrans uint32 `protobuf:"varint,1004,opt,name=inet_diag_msg_retrans,json=inetDiagMsgRetrans,proto3" json:"inet_diag_msg_retrans,omitempty"` // uint8 - InetDiagMsgSocketSourcePort uint32 `protobuf:"varint,1005,opt,name=inet_diag_msg_socket_source_port,json=inetDiagMsgSocketSourcePort,proto3" json:"inet_diag_msg_socket_source_port,omitempty"` // __be16 - InetDiagMsgSocketDestinationPort uint32 `protobuf:"varint,1006,opt,name=inet_diag_msg_socket_destination_port,json=inetDiagMsgSocketDestinationPort,proto3" json:"inet_diag_msg_socket_destination_port,omitempty"` // __be16 - InetDiagMsgSocketSource []byte `protobuf:"bytes,1007,opt,name=inet_diag_msg_socket_source,json=inetDiagMsgSocketSource,proto3" json:"inet_diag_msg_socket_source,omitempty"` - InetDiagMsgSocketDestination []byte `protobuf:"bytes,1008,opt,name=inet_diag_msg_socket_destination,json=inetDiagMsgSocketDestination,proto3" json:"inet_diag_msg_socket_destination,omitempty"` - InetDiagMsgSocketInterface uint32 `protobuf:"varint,1009,opt,name=inet_diag_msg_socket_interface,json=inetDiagMsgSocketInterface,proto3" json:"inet_diag_msg_socket_interface,omitempty"` - InetDiagMsgSocketCookie uint64 `protobuf:"varint,1010,opt,name=inet_diag_msg_socket_cookie,json=inetDiagMsgSocketCookie,proto3" json:"inet_diag_msg_socket_cookie,omitempty"` // [2]uint32 - InetDiagMsgSocketDestAsn uint64 `protobuf:"varint,1011,opt,name=inet_diag_msg_socket_dest_asn,json=inetDiagMsgSocketDestAsn,proto3" json:"inet_diag_msg_socket_dest_asn,omitempty"` - InetDiagMsgSocketNextHopAsn uint64 `protobuf:"varint,1012,opt,name=inet_diag_msg_socket_next_hop_asn,json=inetDiagMsgSocketNextHopAsn,proto3" json:"inet_diag_msg_socket_next_hop_asn,omitempty"` - InetDiagMsgExpires uint32 `protobuf:"varint,1013,opt,name=inet_diag_msg_expires,json=inetDiagMsgExpires,proto3" json:"inet_diag_msg_expires,omitempty"` - InetDiagMsgRqueue uint32 `protobuf:"varint,1014,opt,name=inet_diag_msg_rqueue,json=inetDiagMsgRqueue,proto3" json:"inet_diag_msg_rqueue,omitempty"` - InetDiagMsgWqueue uint32 `protobuf:"varint,1015,opt,name=inet_diag_msg_wqueue,json=inetDiagMsgWqueue,proto3" json:"inet_diag_msg_wqueue,omitempty"` - InetDiagMsgUid uint32 `protobuf:"varint,1016,opt,name=inet_diag_msg_uid,json=inetDiagMsgUid,proto3" json:"inet_diag_msg_uid,omitempty"` - InetDiagMsgInode uint32 `protobuf:"varint,1017,opt,name=inet_diag_msg_inode,json=inetDiagMsgInode,proto3" json:"inet_diag_msg_inode,omitempty"` - // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range - // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the - // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the - // destination IP is not in the feed set. - InetDiagMsgSocketDestNetworkOwner string `protobuf:"bytes,1018,opt,name=inet_diag_msg_socket_dest_network_owner,json=inetDiagMsgSocketDestNetworkOwner,proto3" json:"inet_diag_msg_socket_dest_network_owner,omitempty"` - InetDiagMsgSocketDestLocality XtcpFlatRecord_Locality `protobuf:"varint,1019,opt,name=inet_diag_msg_socket_dest_locality,json=inetDiagMsgSocketDestLocality,proto3,enum=xtcp_flat_record.v1.XtcpFlatRecord_Locality" json:"inet_diag_msg_socket_dest_locality,omitempty"` + // Same layout as slot 1 (NIC 200-207, LLDP 220-224). + Uplink2Ifname string `protobuf:"bytes,200,opt,name=uplink2_ifname,json=uplink2Ifname,proto3" json:"uplink2_ifname,omitempty"` + Uplink2NicDriver string `protobuf:"bytes,201,opt,name=uplink2_nic_driver,json=uplink2NicDriver,proto3" json:"uplink2_nic_driver,omitempty"` + Uplink2NicModel string `protobuf:"bytes,202,opt,name=uplink2_nic_model,json=uplink2NicModel,proto3" json:"uplink2_nic_model,omitempty"` + Uplink2NicPciVendor uint32 `protobuf:"varint,203,opt,name=uplink2_nic_pci_vendor,json=uplink2NicPciVendor,proto3" json:"uplink2_nic_pci_vendor,omitempty"` + Uplink2NicPciDevice uint32 `protobuf:"varint,204,opt,name=uplink2_nic_pci_device,json=uplink2NicPciDevice,proto3" json:"uplink2_nic_pci_device,omitempty"` + Uplink2NicBusInfo string `protobuf:"bytes,205,opt,name=uplink2_nic_bus_info,json=uplink2NicBusInfo,proto3" json:"uplink2_nic_bus_info,omitempty"` + Uplink2NicSpeedMbps uint32 `protobuf:"varint,206,opt,name=uplink2_nic_speed_mbps,json=uplink2NicSpeedMbps,proto3" json:"uplink2_nic_speed_mbps,omitempty"` + Uplink2NicFwVersion string `protobuf:"bytes,207,opt,name=uplink2_nic_fw_version,json=uplink2NicFwVersion,proto3" json:"uplink2_nic_fw_version,omitempty"` + Uplink2LldpChassisName string `protobuf:"bytes,220,opt,name=uplink2_lldp_chassis_name,json=uplink2LldpChassisName,proto3" json:"uplink2_lldp_chassis_name,omitempty"` + Uplink2LldpChassisId string `protobuf:"bytes,221,opt,name=uplink2_lldp_chassis_id,json=uplink2LldpChassisId,proto3" json:"uplink2_lldp_chassis_id,omitempty"` + Uplink2LldpMgmtIp string `protobuf:"bytes,222,opt,name=uplink2_lldp_mgmt_ip,json=uplink2LldpMgmtIp,proto3" json:"uplink2_lldp_mgmt_ip,omitempty"` + Uplink2LldpPortId string `protobuf:"bytes,223,opt,name=uplink2_lldp_port_id,json=uplink2LldpPortId,proto3" json:"uplink2_lldp_port_id,omitempty"` + Uplink2LldpPortDescr string `protobuf:"bytes,224,opt,name=uplink2_lldp_port_descr,json=uplink2LldpPortDescr,proto3" json:"uplink2_lldp_port_descr,omitempty"` + // ---- enrichment: socket-side (300-309) ----------------------------------- + // Human name of the interface the socket is BOUND to, i.e. the resolved form + // of inet_diag_msg_socket_interface (1009, the kernel idiag_if index) via the + // namespace's RTM_GETLINK dump. Empty when idiag_if is 0 (the common case — + // most sockets are not SO_BINDTODEVICE-bound) or the index is unknown. + EnrichSocketInterfaceName string `protobuf:"bytes,300,opt,name=enrich_socket_interface_name,json=enrichSocketInterfaceName,proto3" json:"enrich_socket_interface_name,omitempty"` // 301-309 free (301/302 retired, see reserved). + EnrichSocketDestLocality XtcpFlatRecord_Locality `protobuf:"varint,310,opt,name=enrich_socket_dest_locality,json=enrichSocketDestLocality,proto3,enum=xtcp_flat_record.v1.XtcpFlatRecord_Locality" json:"enrich_socket_dest_locality,omitempty"` + // The EGRESS interface for the destination, derived from the socket's own + // namespace routing table: the Oif of the route the destination longest-prefix + // matches (pkg/localnet). Unlike interface_name (1009/300) this is populated + // even for unbound sockets — it is "which NIC does traffic to this dest leave + // on". ifindex is the raw kernel index; ifname is it resolved via RTM_GETLINK. + // 0 / empty when the locality enricher is disabled or no route matched. + EnrichSocketDestEgressIfindex uint32 `protobuf:"varint,311,opt,name=enrich_socket_dest_egress_ifindex,json=enrichSocketDestEgressIfindex,proto3" json:"enrich_socket_dest_egress_ifindex,omitempty"` + EnrichSocketDestEgressIfname string `protobuf:"bytes,312,opt,name=enrich_socket_dest_egress_ifname,json=enrichSocketDestEgressIfname,proto3" json:"enrich_socket_dest_egress_ifname,omitempty"` // 313-319 free (destination routing/locality extras). + // Populated by the opt-in ASN enricher (pkg/ipasn) only for REMOTE + // destinations. 0 / empty when disabled or the destination IP is not in the + // feed set. network_owner is a human name (e.g. "cloudflare", "aws"). + // dest_next_hop_asn is the first-hop transit ASN toward dest; currently + // always 0 (no BGP RIB source yet) — reserved for that feed. + EnrichSocketDestAsn uint64 `protobuf:"varint,320,opt,name=enrich_socket_dest_asn,json=enrichSocketDestAsn,proto3" json:"enrich_socket_dest_asn,omitempty"` + EnrichSocketDestNextHopAsn uint64 `protobuf:"varint,321,opt,name=enrich_socket_dest_next_hop_asn,json=enrichSocketDestNextHopAsn,proto3" json:"enrich_socket_dest_next_hop_asn,omitempty"` + EnrichSocketDestNetworkOwner string `protobuf:"bytes,322,opt,name=enrich_socket_dest_network_owner,json=enrichSocketDestNetworkOwner,proto3" json:"enrich_socket_dest_network_owner,omitempty"` // 323-349 free (destination identity/ownership extras). + // ---- payload: struct inet_diag_msg (1000s) -------------------------------- + // The fixed header of every SOCK_DIAG_BY_FAMILY reply (inet_diag.h). + // Free: 1000, 1018-1099 (1011/1012/1018/1019 retired, see reserved). + InetDiagMsgFamily uint32 `protobuf:"varint,1001,opt,name=inet_diag_msg_family,json=inetDiagMsgFamily,proto3" json:"inet_diag_msg_family,omitempty"` // struct inet_diag_msg.idiag_family (__u8) AF_INET/AF_INET6 + InetDiagMsgState uint32 `protobuf:"varint,1002,opt,name=inet_diag_msg_state,json=inetDiagMsgState,proto3" json:"inet_diag_msg_state,omitempty"` // struct inet_diag_msg.idiag_state (__u8) TCP_ESTABLISHED..TCP_NEW_SYN_RECV + InetDiagMsgTimer uint32 `protobuf:"varint,1003,opt,name=inet_diag_msg_timer,json=inetDiagMsgTimer,proto3" json:"inet_diag_msg_timer,omitempty"` // struct inet_diag_msg.idiag_timer (__u8) 0 none,1 retransmit,2 keepalive,3 timewait,4 zero-window probe + InetDiagMsgRetrans uint32 `protobuf:"varint,1004,opt,name=inet_diag_msg_retrans,json=inetDiagMsgRetrans,proto3" json:"inet_diag_msg_retrans,omitempty"` // struct inet_diag_msg.idiag_retrans (__u8) + InetDiagMsgSocketSourcePort uint32 `protobuf:"varint,1005,opt,name=inet_diag_msg_socket_source_port,json=inetDiagMsgSocketSourcePort,proto3" json:"inet_diag_msg_socket_source_port,omitempty"` // struct inet_diag_msg.id.idiag_sport (__be16) host order here + InetDiagMsgSocketDestinationPort uint32 `protobuf:"varint,1006,opt,name=inet_diag_msg_socket_destination_port,json=inetDiagMsgSocketDestinationPort,proto3" json:"inet_diag_msg_socket_destination_port,omitempty"` // struct inet_diag_msg.id.idiag_dport (__be16) host order here + InetDiagMsgSocketSource []byte `protobuf:"bytes,1007,opt,name=inet_diag_msg_socket_source,json=inetDiagMsgSocketSource,proto3" json:"inet_diag_msg_socket_source,omitempty"` // struct inet_diag_msg.id.idiag_src (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + InetDiagMsgSocketDestination []byte `protobuf:"bytes,1008,opt,name=inet_diag_msg_socket_destination,json=inetDiagMsgSocketDestination,proto3" json:"inet_diag_msg_socket_destination,omitempty"` // struct inet_diag_msg.id.idiag_dst (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + InetDiagMsgSocketInterface uint32 `protobuf:"varint,1009,opt,name=inet_diag_msg_socket_interface,json=inetDiagMsgSocketInterface,proto3" json:"inet_diag_msg_socket_interface,omitempty"` // struct inet_diag_msg.id.idiag_if (__u32) bound ifindex, 0 unbound (name: 300) + InetDiagMsgSocketCookie uint64 `protobuf:"varint,1010,opt,name=inet_diag_msg_socket_cookie,json=inetDiagMsgSocketCookie,proto3" json:"inet_diag_msg_socket_cookie,omitempty"` // struct inet_diag_msg.id.idiag_cookie (__u32[2]) packed lo|hi<<32 + InetDiagMsgExpires uint32 `protobuf:"varint,1013,opt,name=inet_diag_msg_expires,json=inetDiagMsgExpires,proto3" json:"inet_diag_msg_expires,omitempty"` // struct inet_diag_msg.idiag_expires (__u32) ms until idiag_timer fires + InetDiagMsgRqueue uint32 `protobuf:"varint,1014,opt,name=inet_diag_msg_rqueue,json=inetDiagMsgRqueue,proto3" json:"inet_diag_msg_rqueue,omitempty"` // struct inet_diag_msg.idiag_rqueue (__u32) + InetDiagMsgWqueue uint32 `protobuf:"varint,1015,opt,name=inet_diag_msg_wqueue,json=inetDiagMsgWqueue,proto3" json:"inet_diag_msg_wqueue,omitempty"` // struct inet_diag_msg.idiag_wqueue (__u32) + InetDiagMsgUid uint32 `protobuf:"varint,1016,opt,name=inet_diag_msg_uid,json=inetDiagMsgUid,proto3" json:"inet_diag_msg_uid,omitempty"` // struct inet_diag_msg.idiag_uid (__u32) + InetDiagMsgInode uint32 `protobuf:"varint,1017,opt,name=inet_diag_msg_inode,json=inetDiagMsgInode,proto3" json:"inet_diag_msg_inode,omitempty"` // struct inet_diag_msg.idiag_inode (__u32) + // ---- payload: struct inet_diag_meminfo, INET_DIAG_MEMINFO 1 (1100s) ------- // DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by // default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), // so these ship as 0 on current records. The same values live in sk_mem_info: @@ -341,113 +389,139 @@ type XtcpFlatRecord struct { // // Field numbers retained (never reused); enable with `-deserializers all`. // (Not marked `[deprecated = true]` so the still-supported opt-in decode path - // and tests don't trip staticcheck SA1019.) - MemInfoRmem uint32 `protobuf:"varint,1101,opt,name=mem_info_rmem,json=memInfoRmem,proto3" json:"mem_info_rmem,omitempty"` - MemInfoWmem uint32 `protobuf:"varint,1102,opt,name=mem_info_wmem,json=memInfoWmem,proto3" json:"mem_info_wmem,omitempty"` - MemInfoFmem uint32 `protobuf:"varint,1103,opt,name=mem_info_fmem,json=memInfoFmem,proto3" json:"mem_info_fmem,omitempty"` - MemInfoTmem uint32 `protobuf:"varint,1104,opt,name=mem_info_tmem,json=memInfoTmem,proto3" json:"mem_info_tmem,omitempty"` - TcpInfoState uint32 `protobuf:"varint,1201,opt,name=tcp_info_state,json=tcpInfoState,proto3" json:"tcp_info_state,omitempty"` // uint8 - TcpInfoCaState uint32 `protobuf:"varint,1202,opt,name=tcp_info_ca_state,json=tcpInfoCaState,proto3" json:"tcp_info_ca_state,omitempty"` // uint8 - TcpInfoRetransmits uint32 `protobuf:"varint,1203,opt,name=tcp_info_retransmits,json=tcpInfoRetransmits,proto3" json:"tcp_info_retransmits,omitempty"` // uint8 - TcpInfoProbes uint32 `protobuf:"varint,1204,opt,name=tcp_info_probes,json=tcpInfoProbes,proto3" json:"tcp_info_probes,omitempty"` // uint8 - TcpInfoBackoff uint32 `protobuf:"varint,1205,opt,name=tcp_info_backoff,json=tcpInfoBackoff,proto3" json:"tcp_info_backoff,omitempty"` // uint8 - TcpInfoOptions uint32 `protobuf:"varint,1206,opt,name=tcp_info_options,json=tcpInfoOptions,proto3" json:"tcp_info_options,omitempty"` // uint8 - // __u8 _snd_wscale : 4, _rcv_wscale : 4; - // __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; - TcpInfoSendScale uint32 `protobuf:"varint,1207,opt,name=tcp_info_send_scale,json=tcpInfoSendScale,proto3" json:"tcp_info_send_scale,omitempty"` // uint4 - TcpInfoRcvScale uint32 `protobuf:"varint,1208,opt,name=tcp_info_rcv_scale,json=tcpInfoRcvScale,proto3" json:"tcp_info_rcv_scale,omitempty"` // uint4 - TcpInfoDeliveryRateAppLimited uint32 `protobuf:"varint,1209,opt,name=tcp_info_delivery_rate_app_limited,json=tcpInfoDeliveryRateAppLimited,proto3" json:"tcp_info_delivery_rate_app_limited,omitempty"` // uint8 - TcpInfoFastOpenClientFailed uint32 `protobuf:"varint,1210,opt,name=tcp_info_fast_open_client_failed,json=tcpInfoFastOpenClientFailed,proto3" json:"tcp_info_fast_open_client_failed,omitempty"` // uint8 - TcpInfoRto uint32 `protobuf:"varint,1215,opt,name=tcp_info_rto,json=tcpInfoRto,proto3" json:"tcp_info_rto,omitempty"` - TcpInfoAto uint32 `protobuf:"varint,1216,opt,name=tcp_info_ato,json=tcpInfoAto,proto3" json:"tcp_info_ato,omitempty"` - TcpInfoSndMss uint32 `protobuf:"varint,1217,opt,name=tcp_info_snd_mss,json=tcpInfoSndMss,proto3" json:"tcp_info_snd_mss,omitempty"` - TcpInfoRcvMss uint32 `protobuf:"varint,1218,opt,name=tcp_info_rcv_mss,json=tcpInfoRcvMss,proto3" json:"tcp_info_rcv_mss,omitempty"` - TcpInfoUnacked uint32 `protobuf:"varint,1219,opt,name=tcp_info_unacked,json=tcpInfoUnacked,proto3" json:"tcp_info_unacked,omitempty"` - TcpInfoSacked uint32 `protobuf:"varint,1220,opt,name=tcp_info_sacked,json=tcpInfoSacked,proto3" json:"tcp_info_sacked,omitempty"` - TcpInfoLost uint32 `protobuf:"varint,1221,opt,name=tcp_info_lost,json=tcpInfoLost,proto3" json:"tcp_info_lost,omitempty"` - TcpInfoRetrans uint32 `protobuf:"varint,1222,opt,name=tcp_info_retrans,json=tcpInfoRetrans,proto3" json:"tcp_info_retrans,omitempty"` - TcpInfoFackets uint32 `protobuf:"varint,1223,opt,name=tcp_info_fackets,json=tcpInfoFackets,proto3" json:"tcp_info_fackets,omitempty"` + // and tests don't trip staticcheck SA1019.) Free: 1100, 1105-1199. + MemInfoRmem uint32 `protobuf:"varint,1101,opt,name=mem_info_rmem,json=memInfoRmem,proto3" json:"mem_info_rmem,omitempty"` // struct inet_diag_meminfo.idiag_rmem (__u32) + MemInfoWmem uint32 `protobuf:"varint,1102,opt,name=mem_info_wmem,json=memInfoWmem,proto3" json:"mem_info_wmem,omitempty"` // struct inet_diag_meminfo.idiag_wmem (__u32) + MemInfoFmem uint32 `protobuf:"varint,1103,opt,name=mem_info_fmem,json=memInfoFmem,proto3" json:"mem_info_fmem,omitempty"` // struct inet_diag_meminfo.idiag_fmem (__u32) + MemInfoTmem uint32 `protobuf:"varint,1104,opt,name=mem_info_tmem,json=memInfoTmem,proto3" json:"mem_info_tmem,omitempty"` // struct inet_diag_meminfo.idiag_tmem (__u32) + // ---- payload: struct tcp_info, INET_DIAG_INFO 2 (1200s) ------------------- + // Declared in struct order (tcp.h). The kernel appends members over time and + // DeserializeTCPInfo (pkg/xtcpnl) accepts every historical struct size, so + // members newer than the running kernel decode as 0. + // Free: 1200, 1211-1214, 1277-1299. 1266-1276 are PRE-ASSIGNED (see below). + TcpInfoState uint32 `protobuf:"varint,1201,opt,name=tcp_info_state,json=tcpInfoState,proto3" json:"tcp_info_state,omitempty"` // struct tcp_info.tcpi_state (__u8) + TcpInfoCaState uint32 `protobuf:"varint,1202,opt,name=tcp_info_ca_state,json=tcpInfoCaState,proto3" json:"tcp_info_ca_state,omitempty"` // struct tcp_info.tcpi_ca_state (__u8) TCP_CA_Open..TCP_CA_Loss + TcpInfoRetransmits uint32 `protobuf:"varint,1203,opt,name=tcp_info_retransmits,json=tcpInfoRetransmits,proto3" json:"tcp_info_retransmits,omitempty"` // struct tcp_info.tcpi_retransmits (__u8) + TcpInfoProbes uint32 `protobuf:"varint,1204,opt,name=tcp_info_probes,json=tcpInfoProbes,proto3" json:"tcp_info_probes,omitempty"` // struct tcp_info.tcpi_probes (__u8) + TcpInfoBackoff uint32 `protobuf:"varint,1205,opt,name=tcp_info_backoff,json=tcpInfoBackoff,proto3" json:"tcp_info_backoff,omitempty"` // struct tcp_info.tcpi_backoff (__u8) + TcpInfoOptions uint32 `protobuf:"varint,1206,opt,name=tcp_info_options,json=tcpInfoOptions,proto3" json:"tcp_info_options,omitempty"` // struct tcp_info.tcpi_options (__u8) TCPI_OPT_* bitmask + TcpInfoSndWscale uint32 `protobuf:"varint,1207,opt,name=tcp_info_snd_wscale,json=tcpInfoSndWscale,proto3" json:"tcp_info_snd_wscale,omitempty"` // struct tcp_info.tcpi_snd_wscale (__u8:4) + TcpInfoRcvWscale uint32 `protobuf:"varint,1208,opt,name=tcp_info_rcv_wscale,json=tcpInfoRcvWscale,proto3" json:"tcp_info_rcv_wscale,omitempty"` // struct tcp_info.tcpi_rcv_wscale (__u8:4) + TcpInfoDeliveryRateAppLimited uint32 `protobuf:"varint,1209,opt,name=tcp_info_delivery_rate_app_limited,json=tcpInfoDeliveryRateAppLimited,proto3" json:"tcp_info_delivery_rate_app_limited,omitempty"` // struct tcp_info.tcpi_delivery_rate_app_limited (__u8:1) + TcpInfoFastopenClientFail uint32 `protobuf:"varint,1210,opt,name=tcp_info_fastopen_client_fail,json=tcpInfoFastopenClientFail,proto3" json:"tcp_info_fastopen_client_fail,omitempty"` // struct tcp_info.tcpi_fastopen_client_fail (__u8:2) + TcpInfoRto uint32 `protobuf:"varint,1215,opt,name=tcp_info_rto,json=tcpInfoRto,proto3" json:"tcp_info_rto,omitempty"` // struct tcp_info.tcpi_rto (__u32) usec + TcpInfoAto uint32 `protobuf:"varint,1216,opt,name=tcp_info_ato,json=tcpInfoAto,proto3" json:"tcp_info_ato,omitempty"` // struct tcp_info.tcpi_ato (__u32) usec + TcpInfoSndMss uint32 `protobuf:"varint,1217,opt,name=tcp_info_snd_mss,json=tcpInfoSndMss,proto3" json:"tcp_info_snd_mss,omitempty"` // struct tcp_info.tcpi_snd_mss (__u32) + TcpInfoRcvMss uint32 `protobuf:"varint,1218,opt,name=tcp_info_rcv_mss,json=tcpInfoRcvMss,proto3" json:"tcp_info_rcv_mss,omitempty"` // struct tcp_info.tcpi_rcv_mss (__u32) + TcpInfoUnacked uint32 `protobuf:"varint,1219,opt,name=tcp_info_unacked,json=tcpInfoUnacked,proto3" json:"tcp_info_unacked,omitempty"` // struct tcp_info.tcpi_unacked (__u32) + TcpInfoSacked uint32 `protobuf:"varint,1220,opt,name=tcp_info_sacked,json=tcpInfoSacked,proto3" json:"tcp_info_sacked,omitempty"` // struct tcp_info.tcpi_sacked (__u32) + TcpInfoLost uint32 `protobuf:"varint,1221,opt,name=tcp_info_lost,json=tcpInfoLost,proto3" json:"tcp_info_lost,omitempty"` // struct tcp_info.tcpi_lost (__u32) + TcpInfoRetrans uint32 `protobuf:"varint,1222,opt,name=tcp_info_retrans,json=tcpInfoRetrans,proto3" json:"tcp_info_retrans,omitempty"` // struct tcp_info.tcpi_retrans (__u32) + TcpInfoFackets uint32 `protobuf:"varint,1223,opt,name=tcp_info_fackets,json=tcpInfoFackets,proto3" json:"tcp_info_fackets,omitempty"` // struct tcp_info.tcpi_fackets (__u32) // Times - TcpInfoLastDataSent uint32 `protobuf:"varint,1224,opt,name=tcp_info_last_data_sent,json=tcpInfoLastDataSent,proto3" json:"tcp_info_last_data_sent,omitempty"` - TcpInfoLastAckSent uint32 `protobuf:"varint,1225,opt,name=tcp_info_last_ack_sent,json=tcpInfoLastAckSent,proto3" json:"tcp_info_last_ack_sent,omitempty"` - TcpInfoLastDataRecv uint32 `protobuf:"varint,1226,opt,name=tcp_info_last_data_recv,json=tcpInfoLastDataRecv,proto3" json:"tcp_info_last_data_recv,omitempty"` - TcpInfoLastAckRecv uint32 `protobuf:"varint,1227,opt,name=tcp_info_last_ack_recv,json=tcpInfoLastAckRecv,proto3" json:"tcp_info_last_ack_recv,omitempty"` + TcpInfoLastDataSent uint32 `protobuf:"varint,1224,opt,name=tcp_info_last_data_sent,json=tcpInfoLastDataSent,proto3" json:"tcp_info_last_data_sent,omitempty"` // struct tcp_info.tcpi_last_data_sent (__u32) ms ago + TcpInfoLastAckSent uint32 `protobuf:"varint,1225,opt,name=tcp_info_last_ack_sent,json=tcpInfoLastAckSent,proto3" json:"tcp_info_last_ack_sent,omitempty"` // struct tcp_info.tcpi_last_ack_sent (__u32) "Not remembered, sorry." (always 0) + TcpInfoLastDataRecv uint32 `protobuf:"varint,1226,opt,name=tcp_info_last_data_recv,json=tcpInfoLastDataRecv,proto3" json:"tcp_info_last_data_recv,omitempty"` // struct tcp_info.tcpi_last_data_recv (__u32) ms ago + TcpInfoLastAckRecv uint32 `protobuf:"varint,1227,opt,name=tcp_info_last_ack_recv,json=tcpInfoLastAckRecv,proto3" json:"tcp_info_last_ack_recv,omitempty"` // struct tcp_info.tcpi_last_ack_recv (__u32) ms ago // Metrics - TcpInfoPmtu uint32 `protobuf:"varint,1228,opt,name=tcp_info_pmtu,json=tcpInfoPmtu,proto3" json:"tcp_info_pmtu,omitempty"` - TcpInfoRcvSsthresh uint32 `protobuf:"varint,1229,opt,name=tcp_info_rcv_ssthresh,json=tcpInfoRcvSsthresh,proto3" json:"tcp_info_rcv_ssthresh,omitempty"` - TcpInfoRtt uint32 `protobuf:"varint,1230,opt,name=tcp_info_rtt,json=tcpInfoRtt,proto3" json:"tcp_info_rtt,omitempty"` - TcpInfoRttVar uint32 `protobuf:"varint,1231,opt,name=tcp_info_rtt_var,json=tcpInfoRttVar,proto3" json:"tcp_info_rtt_var,omitempty"` - TcpInfoSndSsthresh uint32 `protobuf:"varint,1232,opt,name=tcp_info_snd_ssthresh,json=tcpInfoSndSsthresh,proto3" json:"tcp_info_snd_ssthresh,omitempty"` - TcpInfoSndCwnd uint32 `protobuf:"varint,1233,opt,name=tcp_info_snd_cwnd,json=tcpInfoSndCwnd,proto3" json:"tcp_info_snd_cwnd,omitempty"` - TcpInfoAdvMss uint32 `protobuf:"varint,1234,opt,name=tcp_info_adv_mss,json=tcpInfoAdvMss,proto3" json:"tcp_info_adv_mss,omitempty"` - TcpInfoReordering uint32 `protobuf:"varint,1235,opt,name=tcp_info_reordering,json=tcpInfoReordering,proto3" json:"tcp_info_reordering,omitempty"` - TcpInfoRcvRtt uint32 `protobuf:"varint,1236,opt,name=tcp_info_rcv_rtt,json=tcpInfoRcvRtt,proto3" json:"tcp_info_rcv_rtt,omitempty"` - TcpInfoRcvSpace uint32 `protobuf:"varint,1237,opt,name=tcp_info_rcv_space,json=tcpInfoRcvSpace,proto3" json:"tcp_info_rcv_space,omitempty"` - TcpInfoTotalRetrans uint32 `protobuf:"varint,1238,opt,name=tcp_info_total_retrans,json=tcpInfoTotalRetrans,proto3" json:"tcp_info_total_retrans,omitempty"` - TcpInfoPacingRate uint64 `protobuf:"varint,1239,opt,name=tcp_info_pacing_rate,json=tcpInfoPacingRate,proto3" json:"tcp_info_pacing_rate,omitempty"` - TcpInfoMaxPacingRate uint64 `protobuf:"varint,1240,opt,name=tcp_info_max_pacing_rate,json=tcpInfoMaxPacingRate,proto3" json:"tcp_info_max_pacing_rate,omitempty"` - TcpInfoBytesAcked uint64 `protobuf:"varint,1241,opt,name=tcp_info_bytes_acked,json=tcpInfoBytesAcked,proto3" json:"tcp_info_bytes_acked,omitempty"` // RFC4898 tcpEStatsAppHCThruOctetsAcked - TcpInfoBytesReceived uint64 `protobuf:"varint,1242,opt,name=tcp_info_bytes_received,json=tcpInfoBytesReceived,proto3" json:"tcp_info_bytes_received,omitempty"` // RFC4898 tcpEStatsAppHCThruOctetsReceived - TcpInfoSegsOut uint32 `protobuf:"varint,1243,opt,name=tcp_info_segs_out,json=tcpInfoSegsOut,proto3" json:"tcp_info_segs_out,omitempty"` // RFC4898 tcpEStatsPerfSegsOut - TcpInfoSegsIn uint32 `protobuf:"varint,1244,opt,name=tcp_info_segs_in,json=tcpInfoSegsIn,proto3" json:"tcp_info_segs_in,omitempty"` // RFC4898 tcpEStatsPerfSegsIn - TcpInfoNotSentBytes uint32 `protobuf:"varint,1245,opt,name=tcp_info_not_sent_bytes,json=tcpInfoNotSentBytes,proto3" json:"tcp_info_not_sent_bytes,omitempty"` - TcpInfoMinRtt uint32 `protobuf:"varint,1246,opt,name=tcp_info_min_rtt,json=tcpInfoMinRtt,proto3" json:"tcp_info_min_rtt,omitempty"` - TcpInfoDataSegsIn uint32 `protobuf:"varint,1247,opt,name=tcp_info_data_segs_in,json=tcpInfoDataSegsIn,proto3" json:"tcp_info_data_segs_in,omitempty"` // RFC4898 tcpEStatsDataSegsIn - TcpInfoDataSegsOut uint32 `protobuf:"varint,1248,opt,name=tcp_info_data_segs_out,json=tcpInfoDataSegsOut,proto3" json:"tcp_info_data_segs_out,omitempty"` // RFC4898 tcpEStatsDataSegsOut - TcpInfoDeliveryRate uint64 `protobuf:"varint,1249,opt,name=tcp_info_delivery_rate,json=tcpInfoDeliveryRate,proto3" json:"tcp_info_delivery_rate,omitempty"` - TcpInfoBusyTime uint64 `protobuf:"varint,1250,opt,name=tcp_info_busy_time,json=tcpInfoBusyTime,proto3" json:"tcp_info_busy_time,omitempty"` // Time (usec) busy sending data - TcpInfoRwndLimited uint64 `protobuf:"varint,1251,opt,name=tcp_info_rwnd_limited,json=tcpInfoRwndLimited,proto3" json:"tcp_info_rwnd_limited,omitempty"` // Time (usec) limited by receive window - TcpInfoSndbufLimited uint64 `protobuf:"varint,1252,opt,name=tcp_info_sndbuf_limited,json=tcpInfoSndbufLimited,proto3" json:"tcp_info_sndbuf_limited,omitempty"` // Time (usec) limited by send buffer - TcpInfoDelivered uint32 `protobuf:"varint,1253,opt,name=tcp_info_delivered,json=tcpInfoDelivered,proto3" json:"tcp_info_delivered,omitempty"` - TcpInfoDeliveredCe uint32 `protobuf:"varint,1254,opt,name=tcp_info_delivered_ce,json=tcpInfoDeliveredCe,proto3" json:"tcp_info_delivered_ce,omitempty"` + TcpInfoPmtu uint32 `protobuf:"varint,1228,opt,name=tcp_info_pmtu,json=tcpInfoPmtu,proto3" json:"tcp_info_pmtu,omitempty"` // struct tcp_info.tcpi_pmtu (__u32) + TcpInfoRcvSsthresh uint32 `protobuf:"varint,1229,opt,name=tcp_info_rcv_ssthresh,json=tcpInfoRcvSsthresh,proto3" json:"tcp_info_rcv_ssthresh,omitempty"` // struct tcp_info.tcpi_rcv_ssthresh (__u32) + TcpInfoRtt uint32 `protobuf:"varint,1230,opt,name=tcp_info_rtt,json=tcpInfoRtt,proto3" json:"tcp_info_rtt,omitempty"` // struct tcp_info.tcpi_rtt (__u32) smoothed RTT, usec + TcpInfoRttvar uint32 `protobuf:"varint,1231,opt,name=tcp_info_rttvar,json=tcpInfoRttvar,proto3" json:"tcp_info_rttvar,omitempty"` // struct tcp_info.tcpi_rttvar (__u32) RTT variance, usec + TcpInfoSndSsthresh uint32 `protobuf:"varint,1232,opt,name=tcp_info_snd_ssthresh,json=tcpInfoSndSsthresh,proto3" json:"tcp_info_snd_ssthresh,omitempty"` // struct tcp_info.tcpi_snd_ssthresh (__u32) + TcpInfoSndCwnd uint32 `protobuf:"varint,1233,opt,name=tcp_info_snd_cwnd,json=tcpInfoSndCwnd,proto3" json:"tcp_info_snd_cwnd,omitempty"` // struct tcp_info.tcpi_snd_cwnd (__u32) segments + TcpInfoAdvmss uint32 `protobuf:"varint,1234,opt,name=tcp_info_advmss,json=tcpInfoAdvmss,proto3" json:"tcp_info_advmss,omitempty"` // struct tcp_info.tcpi_advmss (__u32) + TcpInfoReordering uint32 `protobuf:"varint,1235,opt,name=tcp_info_reordering,json=tcpInfoReordering,proto3" json:"tcp_info_reordering,omitempty"` // struct tcp_info.tcpi_reordering (__u32) + TcpInfoRcvRtt uint32 `protobuf:"varint,1236,opt,name=tcp_info_rcv_rtt,json=tcpInfoRcvRtt,proto3" json:"tcp_info_rcv_rtt,omitempty"` // struct tcp_info.tcpi_rcv_rtt (__u32) usec + TcpInfoRcvSpace uint32 `protobuf:"varint,1237,opt,name=tcp_info_rcv_space,json=tcpInfoRcvSpace,proto3" json:"tcp_info_rcv_space,omitempty"` // struct tcp_info.tcpi_rcv_space (__u32) + TcpInfoTotalRetrans uint32 `protobuf:"varint,1238,opt,name=tcp_info_total_retrans,json=tcpInfoTotalRetrans,proto3" json:"tcp_info_total_retrans,omitempty"` // struct tcp_info.tcpi_total_retrans (__u32) + TcpInfoPacingRate uint64 `protobuf:"varint,1239,opt,name=tcp_info_pacing_rate,json=tcpInfoPacingRate,proto3" json:"tcp_info_pacing_rate,omitempty"` // struct tcp_info.tcpi_pacing_rate (__u64) bytes/sec + TcpInfoMaxPacingRate uint64 `protobuf:"varint,1240,opt,name=tcp_info_max_pacing_rate,json=tcpInfoMaxPacingRate,proto3" json:"tcp_info_max_pacing_rate,omitempty"` // struct tcp_info.tcpi_max_pacing_rate (__u64) bytes/sec + TcpInfoBytesAcked uint64 `protobuf:"varint,1241,opt,name=tcp_info_bytes_acked,json=tcpInfoBytesAcked,proto3" json:"tcp_info_bytes_acked,omitempty"` // struct tcp_info.tcpi_bytes_acked (__u64) RFC4898 tcpEStatsAppHCThruOctetsAcked + TcpInfoBytesReceived uint64 `protobuf:"varint,1242,opt,name=tcp_info_bytes_received,json=tcpInfoBytesReceived,proto3" json:"tcp_info_bytes_received,omitempty"` // struct tcp_info.tcpi_bytes_received (__u64) RFC4898 tcpEStatsAppHCThruOctetsReceived + TcpInfoSegsOut uint32 `protobuf:"varint,1243,opt,name=tcp_info_segs_out,json=tcpInfoSegsOut,proto3" json:"tcp_info_segs_out,omitempty"` // struct tcp_info.tcpi_segs_out (__u32) RFC4898 tcpEStatsPerfSegsOut + TcpInfoSegsIn uint32 `protobuf:"varint,1244,opt,name=tcp_info_segs_in,json=tcpInfoSegsIn,proto3" json:"tcp_info_segs_in,omitempty"` // struct tcp_info.tcpi_segs_in (__u32) RFC4898 tcpEStatsPerfSegsIn + TcpInfoNotsentBytes uint32 `protobuf:"varint,1245,opt,name=tcp_info_notsent_bytes,json=tcpInfoNotsentBytes,proto3" json:"tcp_info_notsent_bytes,omitempty"` // struct tcp_info.tcpi_notsent_bytes (__u32) + TcpInfoMinRtt uint32 `protobuf:"varint,1246,opt,name=tcp_info_min_rtt,json=tcpInfoMinRtt,proto3" json:"tcp_info_min_rtt,omitempty"` // struct tcp_info.tcpi_min_rtt (__u32) usec + TcpInfoDataSegsIn uint32 `protobuf:"varint,1247,opt,name=tcp_info_data_segs_in,json=tcpInfoDataSegsIn,proto3" json:"tcp_info_data_segs_in,omitempty"` // struct tcp_info.tcpi_data_segs_in (__u32) RFC4898 tcpEStatsDataSegsIn + TcpInfoDataSegsOut uint32 `protobuf:"varint,1248,opt,name=tcp_info_data_segs_out,json=tcpInfoDataSegsOut,proto3" json:"tcp_info_data_segs_out,omitempty"` // struct tcp_info.tcpi_data_segs_out (__u32) RFC4898 tcpEStatsDataSegsOut + TcpInfoDeliveryRate uint64 `protobuf:"varint,1249,opt,name=tcp_info_delivery_rate,json=tcpInfoDeliveryRate,proto3" json:"tcp_info_delivery_rate,omitempty"` // struct tcp_info.tcpi_delivery_rate (__u64) bytes/sec + TcpInfoBusyTime uint64 `protobuf:"varint,1250,opt,name=tcp_info_busy_time,json=tcpInfoBusyTime,proto3" json:"tcp_info_busy_time,omitempty"` // struct tcp_info.tcpi_busy_time (__u64) usec busy sending data + TcpInfoRwndLimited uint64 `protobuf:"varint,1251,opt,name=tcp_info_rwnd_limited,json=tcpInfoRwndLimited,proto3" json:"tcp_info_rwnd_limited,omitempty"` // struct tcp_info.tcpi_rwnd_limited (__u64) usec limited by receive window + TcpInfoSndbufLimited uint64 `protobuf:"varint,1252,opt,name=tcp_info_sndbuf_limited,json=tcpInfoSndbufLimited,proto3" json:"tcp_info_sndbuf_limited,omitempty"` // struct tcp_info.tcpi_sndbuf_limited (__u64) usec limited by send buffer + // 4.15 kernel tcp_info ends here (192 bytes); 4.19+ below + TcpInfoDelivered uint32 `protobuf:"varint,1253,opt,name=tcp_info_delivered,json=tcpInfoDelivered,proto3" json:"tcp_info_delivered,omitempty"` // struct tcp_info.tcpi_delivered (__u32) + TcpInfoDeliveredCe uint32 `protobuf:"varint,1254,opt,name=tcp_info_delivered_ce,json=tcpInfoDeliveredCe,proto3" json:"tcp_info_delivered_ce,omitempty"` // struct tcp_info.tcpi_delivered_ce (__u32) // https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB - TcpInfoBytesSent uint64 `protobuf:"varint,1255,opt,name=tcp_info_bytes_sent,json=tcpInfoBytesSent,proto3" json:"tcp_info_bytes_sent,omitempty"` // RFC4898 tcpEStatsPerfHCDataOctetsOut - TcpInfoBytesRetrans uint64 `protobuf:"varint,1256,opt,name=tcp_info_bytes_retrans,json=tcpInfoBytesRetrans,proto3" json:"tcp_info_bytes_retrans,omitempty"` // RFC4898 tcpEStatsPerfOctetsRetrans - TcpInfoDsackDups uint32 `protobuf:"varint,1257,opt,name=tcp_info_dsack_dups,json=tcpInfoDsackDups,proto3" json:"tcp_info_dsack_dups,omitempty"` // RFC4898 tcpEStatsStackDSACKDups - TcpInfoReordSeen uint32 `protobuf:"varint,1258,opt,name=tcp_info_reord_seen,json=tcpInfoReordSeen,proto3" json:"tcp_info_reord_seen,omitempty"` // reordering events seen - TcpInfoRcvOoopack uint32 `protobuf:"varint,1259,opt,name=tcp_info_rcv_ooopack,json=tcpInfoRcvOoopack,proto3" json:"tcp_info_rcv_ooopack,omitempty"` // Out-of-order packets received - TcpInfoSndWnd uint32 `protobuf:"varint,1260,opt,name=tcp_info_snd_wnd,json=tcpInfoSndWnd,proto3" json:"tcp_info_snd_wnd,omitempty"` // peer's advertised receive window after scaling (bytes) - TcpInfoRcvWnd uint32 `protobuf:"varint,1261,opt,name=tcp_info_rcv_wnd,json=tcpInfoRcvWnd,proto3" json:"tcp_info_rcv_wnd,omitempty"` // local advertised receive window after scaling (bytes) - TcpInfoRehash uint32 `protobuf:"varint,1262,opt,name=tcp_info_rehash,json=tcpInfoRehash,proto3" json:"tcp_info_rehash,omitempty"` // PLB or timeout triggered rehash attempts - TcpInfoTotalRto uint32 `protobuf:"varint,1263,opt,name=tcp_info_total_rto,json=tcpInfoTotalRto,proto3" json:"tcp_info_total_rto,omitempty"` // Total number of RTO timeouts, including SYN/SYN-ACK and recurring timeouts - TcpInfoTotalRtoRecoveries uint32 `protobuf:"varint,1264,opt,name=tcp_info_total_rto_recoveries,json=tcpInfoTotalRtoRecoveries,proto3" json:"tcp_info_total_rto_recoveries,omitempty"` // Total number of RTO recoveries, including any unfinished recovery - TcpInfoTotalRtoTime uint32 `protobuf:"varint,1265,opt,name=tcp_info_total_rto_time,json=tcpInfoTotalRtoTime,proto3" json:"tcp_info_total_rto_time,omitempty"` // Total time spent in RTO recoveries in milliseconds, including any unfinished recovery - // Please note it's recommended to use the enum for efficency, but keeping the string - // just in case we need to quickly put a different algorithm in without updating the enum. - // Obviously it's optional, so it low cost. - CongestionAlgorithmString string `protobuf:"bytes,1300,opt,name=congestion_algorithm_string,json=congestionAlgorithmString,proto3" json:"congestion_algorithm_string,omitempty"` // INET_DIAG_CONG 4 - CongestionAlgorithmEnum XtcpFlatRecord_CongestionAlgorithm `protobuf:"varint,1301,opt,name=congestion_algorithm_enum,json=congestionAlgorithmEnum,proto3,enum=xtcp_flat_record.v1.XtcpFlatRecord_CongestionAlgorithm" json:"congestion_algorithm_enum,omitempty"` // INET_DIAG_CONG 4 - TypeOfService uint32 `protobuf:"varint,1401,opt,name=type_of_service,json=typeOfService,proto3" json:"type_of_service,omitempty"` // INET_DIAG_TOS 5 uint8 - TrafficClass uint32 `protobuf:"varint,1402,opt,name=traffic_class,json=trafficClass,proto3" json:"traffic_class,omitempty"` // INET_DIAG_TCLASS 6 uint8 - SkMemInfoRmemAlloc uint32 `protobuf:"varint,1501,opt,name=sk_mem_info_rmem_alloc,json=skMemInfoRmemAlloc,proto3" json:"sk_mem_info_rmem_alloc,omitempty"` - SkMemInfoRcvBuf uint32 `protobuf:"varint,1502,opt,name=sk_mem_info_rcv_buf,json=skMemInfoRcvBuf,proto3" json:"sk_mem_info_rcv_buf,omitempty"` - SkMemInfoWmemAlloc uint32 `protobuf:"varint,1503,opt,name=sk_mem_info_wmem_alloc,json=skMemInfoWmemAlloc,proto3" json:"sk_mem_info_wmem_alloc,omitempty"` - SkMemInfoSndBuf uint32 `protobuf:"varint,1504,opt,name=sk_mem_info_snd_buf,json=skMemInfoSndBuf,proto3" json:"sk_mem_info_snd_buf,omitempty"` - SkMemInfoFwdAlloc uint32 `protobuf:"varint,1505,opt,name=sk_mem_info_fwd_alloc,json=skMemInfoFwdAlloc,proto3" json:"sk_mem_info_fwd_alloc,omitempty"` - SkMemInfoWmemQueued uint32 `protobuf:"varint,1506,opt,name=sk_mem_info_wmem_queued,json=skMemInfoWmemQueued,proto3" json:"sk_mem_info_wmem_queued,omitempty"` - SkMemInfoOptmem uint32 `protobuf:"varint,1507,opt,name=sk_mem_info_optmem,json=skMemInfoOptmem,proto3" json:"sk_mem_info_optmem,omitempty"` - SkMemInfoBacklog uint32 `protobuf:"varint,1508,opt,name=sk_mem_info_backlog,json=skMemInfoBacklog,proto3" json:"sk_mem_info_backlog,omitempty"` - SkMemInfoDrops uint32 `protobuf:"varint,1509,opt,name=sk_mem_info_drops,json=skMemInfoDrops,proto3" json:"sk_mem_info_drops,omitempty"` - ShutdownState uint32 `protobuf:"varint,1600,opt,name=shutdown_state,json=shutdownState,proto3" json:"shutdown_state,omitempty"` // UNIX_DIAG_SHUTDOWN 8uint8 - VegasInfoEnabled uint32 `protobuf:"varint,1701,opt,name=vegas_info_enabled,json=vegasInfoEnabled,proto3" json:"vegas_info_enabled,omitempty"` - VegasInfoRttCnt uint32 `protobuf:"varint,1702,opt,name=vegas_info_rtt_cnt,json=vegasInfoRttCnt,proto3" json:"vegas_info_rtt_cnt,omitempty"` - VegasInfoRtt uint32 `protobuf:"varint,1703,opt,name=vegas_info_rtt,json=vegasInfoRtt,proto3" json:"vegas_info_rtt,omitempty"` - VegasInfoMinRtt uint32 `protobuf:"varint,1704,opt,name=vegas_info_min_rtt,json=vegasInfoMinRtt,proto3" json:"vegas_info_min_rtt,omitempty"` - DctcpInfoEnabled uint32 `protobuf:"varint,1801,opt,name=dctcp_info_enabled,json=dctcpInfoEnabled,proto3" json:"dctcp_info_enabled,omitempty"` - DctcpInfoCeState uint32 `protobuf:"varint,1802,opt,name=dctcp_info_ce_state,json=dctcpInfoCeState,proto3" json:"dctcp_info_ce_state,omitempty"` - DctcpInfoAlpha uint32 `protobuf:"varint,1803,opt,name=dctcp_info_alpha,json=dctcpInfoAlpha,proto3" json:"dctcp_info_alpha,omitempty"` - DctcpInfoAbEcn uint32 `protobuf:"varint,1804,opt,name=dctcp_info_ab_ecn,json=dctcpInfoAbEcn,proto3" json:"dctcp_info_ab_ecn,omitempty"` - DctcpInfoAbTot uint32 `protobuf:"varint,1805,opt,name=dctcp_info_ab_tot,json=dctcpInfoAbTot,proto3" json:"dctcp_info_ab_tot,omitempty"` - BbrInfoBwLo uint32 `protobuf:"varint,1901,opt,name=bbr_info_bw_lo,json=bbrInfoBwLo,proto3" json:"bbr_info_bw_lo,omitempty"` - BbrInfoBwHi uint32 `protobuf:"varint,1902,opt,name=bbr_info_bw_hi,json=bbrInfoBwHi,proto3" json:"bbr_info_bw_hi,omitempty"` - BbrInfoMinRtt uint32 `protobuf:"varint,1903,opt,name=bbr_info_min_rtt,json=bbrInfoMinRtt,proto3" json:"bbr_info_min_rtt,omitempty"` - BbrInfoPacingGain uint32 `protobuf:"varint,1904,opt,name=bbr_info_pacing_gain,json=bbrInfoPacingGain,proto3" json:"bbr_info_pacing_gain,omitempty"` - BbrInfoCwndGain uint32 `protobuf:"varint,1905,opt,name=bbr_info_cwnd_gain,json=bbrInfoCwndGain,proto3" json:"bbr_info_cwnd_gain,omitempty"` - ClassId uint32 `protobuf:"varint,2001,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` // INET_DIAG_CLASS_ID 17 uint32 - SockOpt uint32 `protobuf:"varint,2002,opt,name=sock_opt,json=sockOpt,proto3" json:"sock_opt,omitempty"` // INET_DIAG_SOCKOPT - CGroup uint64 `protobuf:"varint,2103,opt,name=c_group,json=cGroup,proto3" json:"c_group,omitempty"` // INET_DIAG_BC_CGROUP_COND - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + TcpInfoBytesSent uint64 `protobuf:"varint,1255,opt,name=tcp_info_bytes_sent,json=tcpInfoBytesSent,proto3" json:"tcp_info_bytes_sent,omitempty"` // struct tcp_info.tcpi_bytes_sent (__u64) RFC4898 tcpEStatsPerfHCDataOctetsOut + TcpInfoBytesRetrans uint64 `protobuf:"varint,1256,opt,name=tcp_info_bytes_retrans,json=tcpInfoBytesRetrans,proto3" json:"tcp_info_bytes_retrans,omitempty"` // struct tcp_info.tcpi_bytes_retrans (__u64) RFC4898 tcpEStatsPerfOctetsRetrans + TcpInfoDsackDups uint32 `protobuf:"varint,1257,opt,name=tcp_info_dsack_dups,json=tcpInfoDsackDups,proto3" json:"tcp_info_dsack_dups,omitempty"` // struct tcp_info.tcpi_dsack_dups (__u32) RFC4898 tcpEStatsStackDSACKDups + TcpInfoReordSeen uint32 `protobuf:"varint,1258,opt,name=tcp_info_reord_seen,json=tcpInfoReordSeen,proto3" json:"tcp_info_reord_seen,omitempty"` // struct tcp_info.tcpi_reord_seen (__u32) reordering events seen + TcpInfoRcvOoopack uint32 `protobuf:"varint,1259,opt,name=tcp_info_rcv_ooopack,json=tcpInfoRcvOoopack,proto3" json:"tcp_info_rcv_ooopack,omitempty"` // struct tcp_info.tcpi_rcv_ooopack (__u32) out-of-order packets received (5.4+) + TcpInfoSndWnd uint32 `protobuf:"varint,1260,opt,name=tcp_info_snd_wnd,json=tcpInfoSndWnd,proto3" json:"tcp_info_snd_wnd,omitempty"` // struct tcp_info.tcpi_snd_wnd (__u32) peer's advertised receive window after scaling, bytes + TcpInfoRcvWnd uint32 `protobuf:"varint,1261,opt,name=tcp_info_rcv_wnd,json=tcpInfoRcvWnd,proto3" json:"tcp_info_rcv_wnd,omitempty"` // struct tcp_info.tcpi_rcv_wnd (__u32) local advertised receive window after scaling, bytes (6.6+) + TcpInfoRehash uint32 `protobuf:"varint,1262,opt,name=tcp_info_rehash,json=tcpInfoRehash,proto3" json:"tcp_info_rehash,omitempty"` // struct tcp_info.tcpi_rehash (__u32) PLB or timeout triggered rehash attempts (6.6+) + TcpInfoTotalRto uint32 `protobuf:"varint,1263,opt,name=tcp_info_total_rto,json=tcpInfoTotalRto,proto3" json:"tcp_info_total_rto,omitempty"` // struct tcp_info.tcpi_total_rto (__u16) RTO timeouts incl. SYN/SYN-ACK and recurring (6.10+) + TcpInfoTotalRtoRecoveries uint32 `protobuf:"varint,1264,opt,name=tcp_info_total_rto_recoveries,json=tcpInfoTotalRtoRecoveries,proto3" json:"tcp_info_total_rto_recoveries,omitempty"` // struct tcp_info.tcpi_total_rto_recoveries (__u16) RTO recoveries incl. any unfinished (6.10+) + TcpInfoTotalRtoTime uint32 `protobuf:"varint,1265,opt,name=tcp_info_total_rto_time,json=tcpInfoTotalRtoTime,proto3" json:"tcp_info_total_rto_time,omitempty"` // struct tcp_info.tcpi_total_rto_time (__u32) ms in RTO recoveries incl. any unfinished (6.10+) + // ---- payload: INET_DIAG_CONG 4 (1300s) ------------------------------------ + // The kernel emits the congestion-control module name as a NUL-terminated + // string (nla_put_string(skb, INET_DIAG_CONG, ca_ops->name), inet_diag.c). + // It's recommended to use the enum for efficiency, but the string is kept so + // an algorithm the enum does not know yet is still visible. Free: 1302-1399. + InetDiagCong string `protobuf:"bytes,1300,opt,name=inet_diag_cong,json=inetDiagCong,proto3" json:"inet_diag_cong,omitempty"` // INET_DIAG_CONG (4): ca_ops->name (char[TCP_CA_NAME_MAX=16], inet_diag.c) + InetDiagCongEnum XtcpFlatRecord_CongestionAlgorithm `protobuf:"varint,1301,opt,name=inet_diag_cong_enum,json=inetDiagCongEnum,proto3,enum=xtcp_flat_record.v1.XtcpFlatRecord_CongestionAlgorithm" json:"inet_diag_cong_enum,omitempty"` // derived by xtcp from inet_diag_cong (not a kernel field) + // ---- payload: INET_DIAG_TOS 5 / INET_DIAG_TCLASS 6 (1400s) ---------------- + // Free: 1400, 1403-1499. + InetDiagTos uint32 `protobuf:"varint,1401,opt,name=inet_diag_tos,json=inetDiagTos,proto3" json:"inet_diag_tos,omitempty"` // INET_DIAG_TOS (5): inet->tos (__u8, inet_diag.c) IPv4 TOS byte + InetDiagTclass uint32 `protobuf:"varint,1402,opt,name=inet_diag_tclass,json=inetDiagTclass,proto3" json:"inet_diag_tclass,omitempty"` // INET_DIAG_TCLASS (6): np->tclass (__u8, inet_diag.c) IPv6 traffic class + // ---- payload: SK_MEMINFO_*, INET_DIAG_SKMEMINFO 7 (1500s) ----------------- + // __u32 mem[SK_MEMINFO_VARS] filled by sk_get_meminfo (net/core/sock.c), + // indexed by enum sock_diag.h SK_MEMINFO_*. Free: 1500, 1510-1599. + SkMemInfoRmemAlloc uint32 `protobuf:"varint,1501,opt,name=sk_mem_info_rmem_alloc,json=skMemInfoRmemAlloc,proto3" json:"sk_mem_info_rmem_alloc,omitempty"` // SK_MEMINFO_RMEM_ALLOC (__u32, sock_diag.h) sk_rmem_alloc + SkMemInfoRcvbuf uint32 `protobuf:"varint,1502,opt,name=sk_mem_info_rcvbuf,json=skMemInfoRcvbuf,proto3" json:"sk_mem_info_rcvbuf,omitempty"` // SK_MEMINFO_RCVBUF (__u32, sock_diag.h) sk_rcvbuf + SkMemInfoWmemAlloc uint32 `protobuf:"varint,1503,opt,name=sk_mem_info_wmem_alloc,json=skMemInfoWmemAlloc,proto3" json:"sk_mem_info_wmem_alloc,omitempty"` // SK_MEMINFO_WMEM_ALLOC (__u32, sock_diag.h) sk_wmem_alloc + SkMemInfoSndbuf uint32 `protobuf:"varint,1504,opt,name=sk_mem_info_sndbuf,json=skMemInfoSndbuf,proto3" json:"sk_mem_info_sndbuf,omitempty"` // SK_MEMINFO_SNDBUF (__u32, sock_diag.h) sk_sndbuf + SkMemInfoFwdAlloc uint32 `protobuf:"varint,1505,opt,name=sk_mem_info_fwd_alloc,json=skMemInfoFwdAlloc,proto3" json:"sk_mem_info_fwd_alloc,omitempty"` // SK_MEMINFO_FWD_ALLOC (__u32, sock_diag.h) sk_forward_alloc + SkMemInfoWmemQueued uint32 `protobuf:"varint,1506,opt,name=sk_mem_info_wmem_queued,json=skMemInfoWmemQueued,proto3" json:"sk_mem_info_wmem_queued,omitempty"` // SK_MEMINFO_WMEM_QUEUED (__u32, sock_diag.h) sk_wmem_queued + SkMemInfoOptmem uint32 `protobuf:"varint,1507,opt,name=sk_mem_info_optmem,json=skMemInfoOptmem,proto3" json:"sk_mem_info_optmem,omitempty"` // SK_MEMINFO_OPTMEM (__u32, sock_diag.h) sk_omem_alloc + SkMemInfoBacklog uint32 `protobuf:"varint,1508,opt,name=sk_mem_info_backlog,json=skMemInfoBacklog,proto3" json:"sk_mem_info_backlog,omitempty"` // SK_MEMINFO_BACKLOG (__u32, sock_diag.h) sk_backlog.len + SkMemInfoDrops uint32 `protobuf:"varint,1509,opt,name=sk_mem_info_drops,json=skMemInfoDrops,proto3" json:"sk_mem_info_drops,omitempty"` // SK_MEMINFO_DROPS (__u32, sock_diag.h) sk_drops + // ---- payload: INET_DIAG_SHUTDOWN 8 (1600s) -------------------------------- + // Free: 1601-1699. + InetDiagShutdown uint32 `protobuf:"varint,1600,opt,name=inet_diag_shutdown,json=inetDiagShutdown,proto3" json:"inet_diag_shutdown,omitempty"` // INET_DIAG_SHUTDOWN (8): sk->sk_shutdown (__u8, inet_diag.c) RCV_SHUTDOWN=1|SEND_SHUTDOWN=2 + // ---- payload: struct tcpvegas_info, INET_DIAG_VEGASINFO 3 (1700s) --------- + // Only present when the socket's CC module is vegas (tcp_vegas.c + // tcp_vegas_get_info). Free: 1700, 1705-1799. + VegasInfoEnabled uint32 `protobuf:"varint,1701,opt,name=vegas_info_enabled,json=vegasInfoEnabled,proto3" json:"vegas_info_enabled,omitempty"` // struct tcpvegas_info.tcpv_enabled (__u32) + VegasInfoRttcnt uint32 `protobuf:"varint,1702,opt,name=vegas_info_rttcnt,json=vegasInfoRttcnt,proto3" json:"vegas_info_rttcnt,omitempty"` // struct tcpvegas_info.tcpv_rttcnt (__u32) + VegasInfoRtt uint32 `protobuf:"varint,1703,opt,name=vegas_info_rtt,json=vegasInfoRtt,proto3" json:"vegas_info_rtt,omitempty"` // struct tcpvegas_info.tcpv_rtt (__u32) usec + VegasInfoMinrtt uint32 `protobuf:"varint,1704,opt,name=vegas_info_minrtt,json=vegasInfoMinrtt,proto3" json:"vegas_info_minrtt,omitempty"` // struct tcpvegas_info.tcpv_minrtt (__u32) usec + // ---- payload: struct tcp_dctcp_info, INET_DIAG_DCTCPINFO 9 (1800s) -------- + // Only present when the socket's CC module is dctcp (tcp_dctcp.c + // dctcp_get_info); requested via the VEGASINFO bit. Free: 1800, 1806-1899. + DctcpInfoEnabled uint32 `protobuf:"varint,1801,opt,name=dctcp_info_enabled,json=dctcpInfoEnabled,proto3" json:"dctcp_info_enabled,omitempty"` // struct tcp_dctcp_info.dctcp_enabled (__u16) + DctcpInfoCeState uint32 `protobuf:"varint,1802,opt,name=dctcp_info_ce_state,json=dctcpInfoCeState,proto3" json:"dctcp_info_ce_state,omitempty"` // struct tcp_dctcp_info.dctcp_ce_state (__u16) + DctcpInfoAlpha uint32 `protobuf:"varint,1803,opt,name=dctcp_info_alpha,json=dctcpInfoAlpha,proto3" json:"dctcp_info_alpha,omitempty"` // struct tcp_dctcp_info.dctcp_alpha (__u32) + DctcpInfoAbEcn uint32 `protobuf:"varint,1804,opt,name=dctcp_info_ab_ecn,json=dctcpInfoAbEcn,proto3" json:"dctcp_info_ab_ecn,omitempty"` // struct tcp_dctcp_info.dctcp_ab_ecn (__u32) + DctcpInfoAbTot uint32 `protobuf:"varint,1805,opt,name=dctcp_info_ab_tot,json=dctcpInfoAbTot,proto3" json:"dctcp_info_ab_tot,omitempty"` // struct tcp_dctcp_info.dctcp_ab_tot (__u32) + // ---- payload: struct tcp_bbr_info, INET_DIAG_BBRINFO 16 (1900s) ----------- + // Only present when the socket's CC module is bbr (tcp_bbr.c bbr_get_info); + // requested via the VEGASINFO bit. Free: 1900, 1906-1999. + BbrInfoBwLo uint32 `protobuf:"varint,1901,opt,name=bbr_info_bw_lo,json=bbrInfoBwLo,proto3" json:"bbr_info_bw_lo,omitempty"` // struct tcp_bbr_info.bbr_bw_lo (__u32) lower 32 bits of bw, bytes/sec + BbrInfoBwHi uint32 `protobuf:"varint,1902,opt,name=bbr_info_bw_hi,json=bbrInfoBwHi,proto3" json:"bbr_info_bw_hi,omitempty"` // struct tcp_bbr_info.bbr_bw_hi (__u32) upper 32 bits of bw + BbrInfoMinRtt uint32 `protobuf:"varint,1903,opt,name=bbr_info_min_rtt,json=bbrInfoMinRtt,proto3" json:"bbr_info_min_rtt,omitempty"` // struct tcp_bbr_info.bbr_min_rtt (__u32) min-filtered RTT, usec + BbrInfoPacingGain uint32 `protobuf:"varint,1904,opt,name=bbr_info_pacing_gain,json=bbrInfoPacingGain,proto3" json:"bbr_info_pacing_gain,omitempty"` // struct tcp_bbr_info.bbr_pacing_gain (__u32) pacing gain << 8 + BbrInfoCwndGain uint32 `protobuf:"varint,1905,opt,name=bbr_info_cwnd_gain,json=bbrInfoCwndGain,proto3" json:"bbr_info_cwnd_gain,omitempty"` // struct tcp_bbr_info.bbr_cwnd_gain (__u32) cwnd gain << 8 + // ---- payload: socket classification attributes (2000s) -------------------- + // INET_DIAG_CLASS_ID 17, INET_DIAG_SOCKOPT 22, INET_DIAG_CGROUP_ID 21 — the + // per-socket scalars inet_diag_msg_attrs_fill emits after the CC extensions. + // Free: 2000, 2004-2099. Next free block: 2100. + InetDiagClassId uint32 `protobuf:"varint,2001,opt,name=inet_diag_class_id,json=inetDiagClassId,proto3" json:"inet_diag_class_id,omitempty"` // INET_DIAG_CLASS_ID (17): classid (__u32, inet_diag.c) net_cls cgroup classid, else sk->sk_priority + InetDiagSockopt uint32 `protobuf:"varint,2002,opt,name=inet_diag_sockopt,json=inetDiagSockopt,proto3" json:"inet_diag_sockopt,omitempty"` // INET_DIAG_SOCKOPT (22): struct inet_diag_sockopt (2 x __u8 bitfields, inet_diag.h) packed little-endian u16: recverr,is_icsk,freebind,hdrincl,mc_loop,transparent,mc_all,nodefrag | bind_address_no_port,recverr_rfc4884,defer_connect + InetDiagCgroupId uint64 `protobuf:"varint,2003,opt,name=inet_diag_cgroup_id,json=inetDiagCgroupId,proto3" json:"inet_diag_cgroup_id,omitempty"` // INET_DIAG_CGROUP_ID (21): cgroup_id(sock_cgroup_ptr(&sk->sk_cgrp_data)) (__u64, inet_diag.c) cgroup v2 id + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *XtcpFlatRecord) Reset() { @@ -781,6 +855,55 @@ func (x *XtcpFlatRecord) GetUplink2LldpPortDescr() string { return "" } +func (x *XtcpFlatRecord) GetEnrichSocketInterfaceName() string { + if x != nil { + return x.EnrichSocketInterfaceName + } + return "" +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestLocality() XtcpFlatRecord_Locality { + if x != nil { + return x.EnrichSocketDestLocality + } + return XtcpFlatRecord_LOCALITY_UNSPECIFIED +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestEgressIfindex() uint32 { + if x != nil { + return x.EnrichSocketDestEgressIfindex + } + return 0 +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestEgressIfname() string { + if x != nil { + return x.EnrichSocketDestEgressIfname + } + return "" +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestAsn() uint64 { + if x != nil { + return x.EnrichSocketDestAsn + } + return 0 +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestNextHopAsn() uint64 { + if x != nil { + return x.EnrichSocketDestNextHopAsn + } + return 0 +} + +func (x *XtcpFlatRecord) GetEnrichSocketDestNetworkOwner() string { + if x != nil { + return x.EnrichSocketDestNetworkOwner + } + return "" +} + func (x *XtcpFlatRecord) GetInetDiagMsgFamily() uint32 { if x != nil { return x.InetDiagMsgFamily @@ -851,20 +974,6 @@ func (x *XtcpFlatRecord) GetInetDiagMsgSocketCookie() uint64 { return 0 } -func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestAsn() uint64 { - if x != nil { - return x.InetDiagMsgSocketDestAsn - } - return 0 -} - -func (x *XtcpFlatRecord) GetInetDiagMsgSocketNextHopAsn() uint64 { - if x != nil { - return x.InetDiagMsgSocketNextHopAsn - } - return 0 -} - func (x *XtcpFlatRecord) GetInetDiagMsgExpires() uint32 { if x != nil { return x.InetDiagMsgExpires @@ -900,20 +1009,6 @@ func (x *XtcpFlatRecord) GetInetDiagMsgInode() uint32 { return 0 } -func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestNetworkOwner() string { - if x != nil { - return x.InetDiagMsgSocketDestNetworkOwner - } - return "" -} - -func (x *XtcpFlatRecord) GetInetDiagMsgSocketDestLocality() XtcpFlatRecord_Locality { - if x != nil { - return x.InetDiagMsgSocketDestLocality - } - return XtcpFlatRecord_LOCALITY_UNSPECIFIED -} - func (x *XtcpFlatRecord) GetMemInfoRmem() uint32 { if x != nil { return x.MemInfoRmem @@ -984,16 +1079,16 @@ func (x *XtcpFlatRecord) GetTcpInfoOptions() uint32 { return 0 } -func (x *XtcpFlatRecord) GetTcpInfoSendScale() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoSndWscale() uint32 { if x != nil { - return x.TcpInfoSendScale + return x.TcpInfoSndWscale } return 0 } -func (x *XtcpFlatRecord) GetTcpInfoRcvScale() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoRcvWscale() uint32 { if x != nil { - return x.TcpInfoRcvScale + return x.TcpInfoRcvWscale } return 0 } @@ -1005,9 +1100,9 @@ func (x *XtcpFlatRecord) GetTcpInfoDeliveryRateAppLimited() uint32 { return 0 } -func (x *XtcpFlatRecord) GetTcpInfoFastOpenClientFailed() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoFastopenClientFail() uint32 { if x != nil { - return x.TcpInfoFastOpenClientFailed + return x.TcpInfoFastopenClientFail } return 0 } @@ -1124,9 +1219,9 @@ func (x *XtcpFlatRecord) GetTcpInfoRtt() uint32 { return 0 } -func (x *XtcpFlatRecord) GetTcpInfoRttVar() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoRttvar() uint32 { if x != nil { - return x.TcpInfoRttVar + return x.TcpInfoRttvar } return 0 } @@ -1145,9 +1240,9 @@ func (x *XtcpFlatRecord) GetTcpInfoSndCwnd() uint32 { return 0 } -func (x *XtcpFlatRecord) GetTcpInfoAdvMss() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoAdvmss() uint32 { if x != nil { - return x.TcpInfoAdvMss + return x.TcpInfoAdvmss } return 0 } @@ -1222,9 +1317,9 @@ func (x *XtcpFlatRecord) GetTcpInfoSegsIn() uint32 { return 0 } -func (x *XtcpFlatRecord) GetTcpInfoNotSentBytes() uint32 { +func (x *XtcpFlatRecord) GetTcpInfoNotsentBytes() uint32 { if x != nil { - return x.TcpInfoNotSentBytes + return x.TcpInfoNotsentBytes } return 0 } @@ -1369,30 +1464,30 @@ func (x *XtcpFlatRecord) GetTcpInfoTotalRtoTime() uint32 { return 0 } -func (x *XtcpFlatRecord) GetCongestionAlgorithmString() string { +func (x *XtcpFlatRecord) GetInetDiagCong() string { if x != nil { - return x.CongestionAlgorithmString + return x.InetDiagCong } return "" } -func (x *XtcpFlatRecord) GetCongestionAlgorithmEnum() XtcpFlatRecord_CongestionAlgorithm { +func (x *XtcpFlatRecord) GetInetDiagCongEnum() XtcpFlatRecord_CongestionAlgorithm { if x != nil { - return x.CongestionAlgorithmEnum + return x.InetDiagCongEnum } return XtcpFlatRecord_CONGESTION_ALGORITHM_UNSPECIFIED } -func (x *XtcpFlatRecord) GetTypeOfService() uint32 { +func (x *XtcpFlatRecord) GetInetDiagTos() uint32 { if x != nil { - return x.TypeOfService + return x.InetDiagTos } return 0 } -func (x *XtcpFlatRecord) GetTrafficClass() uint32 { +func (x *XtcpFlatRecord) GetInetDiagTclass() uint32 { if x != nil { - return x.TrafficClass + return x.InetDiagTclass } return 0 } @@ -1404,9 +1499,9 @@ func (x *XtcpFlatRecord) GetSkMemInfoRmemAlloc() uint32 { return 0 } -func (x *XtcpFlatRecord) GetSkMemInfoRcvBuf() uint32 { +func (x *XtcpFlatRecord) GetSkMemInfoRcvbuf() uint32 { if x != nil { - return x.SkMemInfoRcvBuf + return x.SkMemInfoRcvbuf } return 0 } @@ -1418,9 +1513,9 @@ func (x *XtcpFlatRecord) GetSkMemInfoWmemAlloc() uint32 { return 0 } -func (x *XtcpFlatRecord) GetSkMemInfoSndBuf() uint32 { +func (x *XtcpFlatRecord) GetSkMemInfoSndbuf() uint32 { if x != nil { - return x.SkMemInfoSndBuf + return x.SkMemInfoSndbuf } return 0 } @@ -1460,9 +1555,9 @@ func (x *XtcpFlatRecord) GetSkMemInfoDrops() uint32 { return 0 } -func (x *XtcpFlatRecord) GetShutdownState() uint32 { +func (x *XtcpFlatRecord) GetInetDiagShutdown() uint32 { if x != nil { - return x.ShutdownState + return x.InetDiagShutdown } return 0 } @@ -1474,9 +1569,9 @@ func (x *XtcpFlatRecord) GetVegasInfoEnabled() uint32 { return 0 } -func (x *XtcpFlatRecord) GetVegasInfoRttCnt() uint32 { +func (x *XtcpFlatRecord) GetVegasInfoRttcnt() uint32 { if x != nil { - return x.VegasInfoRttCnt + return x.VegasInfoRttcnt } return 0 } @@ -1488,9 +1583,9 @@ func (x *XtcpFlatRecord) GetVegasInfoRtt() uint32 { return 0 } -func (x *XtcpFlatRecord) GetVegasInfoMinRtt() uint32 { +func (x *XtcpFlatRecord) GetVegasInfoMinrtt() uint32 { if x != nil { - return x.VegasInfoMinRtt + return x.VegasInfoMinrtt } return 0 } @@ -1565,23 +1660,23 @@ func (x *XtcpFlatRecord) GetBbrInfoCwndGain() uint32 { return 0 } -func (x *XtcpFlatRecord) GetClassId() uint32 { +func (x *XtcpFlatRecord) GetInetDiagClassId() uint32 { if x != nil { - return x.ClassId + return x.InetDiagClassId } return 0 } -func (x *XtcpFlatRecord) GetSockOpt() uint32 { +func (x *XtcpFlatRecord) GetInetDiagSockopt() uint32 { if x != nil { - return x.SockOpt + return x.InetDiagSockopt } return 0 } -func (x *XtcpFlatRecord) GetCGroup() uint64 { +func (x *XtcpFlatRecord) GetInetDiagCgroupId() uint64 { if x != nil { - return x.CGroup + return x.InetDiagCgroupId } return 0 } @@ -1624,7 +1719,7 @@ func (*FlatRecordsRequest) Descriptor() ([]byte, []int) { type FlatRecordsResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - XtcpFlatRecord *XtcpFlatRecord `protobuf:"bytes,1,opt,name=xtcp_flat_record,json=xtcpFlatRecord,proto3" json:"xtcp_flat_record,omitempty"` // Envelope.XtcpFlatRecord xtcp_flat_record = 1; + XtcpFlatRecord *XtcpFlatRecord `protobuf:"bytes,1,opt,name=xtcp_flat_record,json=xtcpFlatRecord,proto3" json:"xtcp_flat_record,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1704,7 +1799,7 @@ func (*PollFlatRecordsRequest) Descriptor() ([]byte, []int) { type PollFlatRecordsResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - XtcpFlatRecord *XtcpFlatRecord `protobuf:"bytes,1,opt,name=xtcp_flat_record,json=xtcpFlatRecord,proto3" json:"xtcp_flat_record,omitempty"` // Envelope.XtcpFlatRecord xtcp_flat_record = 1; + XtcpFlatRecord *XtcpFlatRecord `protobuf:"bytes,1,opt,name=xtcp_flat_record,json=xtcpFlatRecord,proto3" json:"xtcp_flat_record,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1753,7 +1848,7 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n" + "\bEnvelope\x125\n" + "\x03row\x18\n" + - " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc6>\n" + + " \x03(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc7D\n" + "\x0eXtcpFlatRecord\x12%\n" + "\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n" + "\x0edaemon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n" + @@ -1799,7 +1894,14 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x120\n" + "\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x120\n" + "\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x126\n" + - "\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x120\n" + + "\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12@\n" + + "\x1cenrich_socket_interface_name\x18\xac\x02 \x01(\tR\x19enrichSocketInterfaceName\x12l\n" + + "\x1benrich_socket_dest_locality\x18\xb6\x02 \x01(\x0e2,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x18enrichSocketDestLocality\x12I\n" + + "!enrich_socket_dest_egress_ifindex\x18\xb7\x02 \x01(\rR\x1denrichSocketDestEgressIfindex\x12G\n" + + " enrich_socket_dest_egress_ifname\x18\xb8\x02 \x01(\tR\x1cenrichSocketDestEgressIfname\x124\n" + + "\x16enrich_socket_dest_asn\x18\xc0\x02 \x01(\x04R\x13enrichSocketDestAsn\x12D\n" + + "\x1fenrich_socket_dest_next_hop_asn\x18\xc1\x02 \x01(\x04R\x1aenrichSocketDestNextHopAsn\x12G\n" + + " enrich_socket_dest_network_owner\x18\xc2\x02 \x01(\tR\x1cenrichSocketDestNetworkOwner\x120\n" + "\x14inet_diag_msg_family\x18\xe9\a \x01(\rR\x11inetDiagMsgFamily\x12.\n" + "\x13inet_diag_msg_state\x18\xea\a \x01(\rR\x10inetDiagMsgState\x12.\n" + "\x13inet_diag_msg_timer\x18\xeb\a \x01(\rR\x10inetDiagMsgTimer\x122\n" + @@ -1809,16 +1911,12 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x1binet_diag_msg_socket_source\x18\xef\a \x01(\fR\x17inetDiagMsgSocketSource\x12G\n" + " inet_diag_msg_socket_destination\x18\xf0\a \x01(\fR\x1cinetDiagMsgSocketDestination\x12C\n" + "\x1einet_diag_msg_socket_interface\x18\xf1\a \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n" + - "\x1binet_diag_msg_socket_cookie\x18\xf2\a \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n" + - "\x1dinet_diag_msg_socket_dest_asn\x18\xf3\a \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n" + - "!inet_diag_msg_socket_next_hop_asn\x18\xf4\a \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x122\n" + + "\x1binet_diag_msg_socket_cookie\x18\xf2\a \x01(\x04R\x17inetDiagMsgSocketCookie\x122\n" + "\x15inet_diag_msg_expires\x18\xf5\a \x01(\rR\x12inetDiagMsgExpires\x120\n" + "\x14inet_diag_msg_rqueue\x18\xf6\a \x01(\rR\x11inetDiagMsgRqueue\x120\n" + "\x14inet_diag_msg_wqueue\x18\xf7\a \x01(\rR\x11inetDiagMsgWqueue\x12*\n" + "\x11inet_diag_msg_uid\x18\xf8\a \x01(\rR\x0einetDiagMsgUid\x12.\n" + - "\x13inet_diag_msg_inode\x18\xf9\a \x01(\rR\x10inetDiagMsgInode\x12S\n" + - "'inet_diag_msg_socket_dest_network_owner\x18\xfa\a \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12x\n" + - "\"inet_diag_msg_socket_dest_locality\x18\xfb\a \x01(\x0e2,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x1dinetDiagMsgSocketDestLocality\x12#\n" + + "\x13inet_diag_msg_inode\x18\xf9\a \x01(\rR\x10inetDiagMsgInode\x12#\n" + "\rmem_info_rmem\x18\xcd\b \x01(\rR\vmemInfoRmem\x12#\n" + "\rmem_info_wmem\x18\xce\b \x01(\rR\vmemInfoWmem\x12#\n" + "\rmem_info_fmem\x18\xcf\b \x01(\rR\vmemInfoFmem\x12#\n" + @@ -1829,10 +1927,10 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n" + "\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n" + "\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n" + - "\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n" + - "\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n" + - "\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12F\n" + - " tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n" + + "\x13tcp_info_snd_wscale\x18\xb7\t \x01(\rR\x10tcpInfoSndWscale\x12.\n" + + "\x13tcp_info_rcv_wscale\x18\xb8\t \x01(\rR\x10tcpInfoRcvWscale\x12J\n" + + "\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12A\n" + + "\x1dtcp_info_fastopen_client_fail\x18\xba\t \x01(\rR\x19tcpInfoFastopenClientFail\x12!\n" + "\ftcp_info_rto\x18\xbf\t \x01(\rR\n" + "tcpInfoRto\x12!\n" + "\ftcp_info_ato\x18\xc0\t \x01(\rR\n" + @@ -1851,11 +1949,11 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\rtcp_info_pmtu\x18\xcc\t \x01(\rR\vtcpInfoPmtu\x122\n" + "\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n" + "\ftcp_info_rtt\x18\xce\t \x01(\rR\n" + - "tcpInfoRtt\x12(\n" + - "\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x122\n" + + "tcpInfoRtt\x12'\n" + + "\x0ftcp_info_rttvar\x18\xcf\t \x01(\rR\rtcpInfoRttvar\x122\n" + "\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n" + - "\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n" + - "\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n" + + "\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12'\n" + + "\x0ftcp_info_advmss\x18\xd2\t \x01(\rR\rtcpInfoAdvmss\x12/\n" + "\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n" + "\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n" + "\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x124\n" + @@ -1865,8 +1963,8 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x126\n" + "\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n" + "\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n" + - "\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x125\n" + - "\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n" + + "\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x124\n" + + "\x16tcp_info_notsent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotsentBytes\x12(\n" + "\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x121\n" + "\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x123\n" + "\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x124\n" + @@ -1886,29 +1984,29 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n" + "\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12A\n" + "\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x125\n" + - "\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n" + - "\x1bcongestion_algorithm_string\x18\x94\n" + - " \x01(\tR\x19congestionAlgorithmString\x12t\n" + - "\x19congestion_algorithm_enum\x18\x95\n" + - " \x01(\x0e27.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17congestionAlgorithmEnum\x12'\n" + - "\x0ftype_of_service\x18\xf9\n" + - " \x01(\rR\rtypeOfService\x12$\n" + - "\rtraffic_class\x18\xfa\n" + - " \x01(\rR\ftrafficClass\x123\n" + - "\x16sk_mem_info_rmem_alloc\x18\xdd\v \x01(\rR\x12skMemInfoRmemAlloc\x12-\n" + - "\x13sk_mem_info_rcv_buf\x18\xde\v \x01(\rR\x0fskMemInfoRcvBuf\x123\n" + - "\x16sk_mem_info_wmem_alloc\x18\xdf\v \x01(\rR\x12skMemInfoWmemAlloc\x12-\n" + - "\x13sk_mem_info_snd_buf\x18\xe0\v \x01(\rR\x0fskMemInfoSndBuf\x121\n" + + "\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12%\n" + + "\x0einet_diag_cong\x18\x94\n" + + " \x01(\tR\finetDiagCong\x12g\n" + + "\x13inet_diag_cong_enum\x18\x95\n" + + " \x01(\x0e27.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x10inetDiagCongEnum\x12#\n" + + "\rinet_diag_tos\x18\xf9\n" + + " \x01(\rR\vinetDiagTos\x12)\n" + + "\x10inet_diag_tclass\x18\xfa\n" + + " \x01(\rR\x0einetDiagTclass\x123\n" + + "\x16sk_mem_info_rmem_alloc\x18\xdd\v \x01(\rR\x12skMemInfoRmemAlloc\x12,\n" + + "\x12sk_mem_info_rcvbuf\x18\xde\v \x01(\rR\x0fskMemInfoRcvbuf\x123\n" + + "\x16sk_mem_info_wmem_alloc\x18\xdf\v \x01(\rR\x12skMemInfoWmemAlloc\x12,\n" + + "\x12sk_mem_info_sndbuf\x18\xe0\v \x01(\rR\x0fskMemInfoSndbuf\x121\n" + "\x15sk_mem_info_fwd_alloc\x18\xe1\v \x01(\rR\x11skMemInfoFwdAlloc\x125\n" + "\x17sk_mem_info_wmem_queued\x18\xe2\v \x01(\rR\x13skMemInfoWmemQueued\x12,\n" + "\x12sk_mem_info_optmem\x18\xe3\v \x01(\rR\x0fskMemInfoOptmem\x12.\n" + "\x13sk_mem_info_backlog\x18\xe4\v \x01(\rR\x10skMemInfoBacklog\x12*\n" + - "\x11sk_mem_info_drops\x18\xe5\v \x01(\rR\x0eskMemInfoDrops\x12&\n" + - "\x0eshutdown_state\x18\xc0\f \x01(\rR\rshutdownState\x12-\n" + - "\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n" + - "\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n" + - "\x0evegas_info_rtt\x18\xa7\r \x01(\rR\fvegasInfoRtt\x12,\n" + - "\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n" + + "\x11sk_mem_info_drops\x18\xe5\v \x01(\rR\x0eskMemInfoDrops\x12-\n" + + "\x12inet_diag_shutdown\x18\xc0\f \x01(\rR\x10inetDiagShutdown\x12-\n" + + "\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12+\n" + + "\x11vegas_info_rttcnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttcnt\x12%\n" + + "\x0evegas_info_rtt\x18\xa7\r \x01(\rR\fvegasInfoRtt\x12+\n" + + "\x11vegas_info_minrtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinrtt\x12-\n" + "\x12dctcp_info_enabled\x18\x89\x0e \x01(\rR\x10dctcpInfoEnabled\x12.\n" + "\x13dctcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10dctcpInfoCeState\x12)\n" + "\x10dctcp_info_alpha\x18\x8b\x0e \x01(\rR\x0edctcpInfoAlpha\x12*\n" + @@ -1918,10 +2016,10 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x0ebbr_info_bw_hi\x18\xee\x0e \x01(\rR\vbbrInfoBwHi\x12(\n" + "\x10bbr_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x120\n" + "\x14bbr_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11bbrInfoPacingGain\x12,\n" + - "\x12bbr_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0fbbrInfoCwndGain\x12\x1a\n" + - "\bclass_id\x18\xd1\x0f \x01(\rR\aclassId\x12\x1a\n" + - "\bsock_opt\x18\xd2\x0f \x01(\rR\asockOpt\x12\x18\n" + - "\ac_group\x18\xb7\x10 \x01(\x04R\x06cGroup\"g\n" + + "\x12bbr_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0fbbrInfoCwndGain\x12,\n" + + "\x12inet_diag_class_id\x18\xd1\x0f \x01(\rR\x0finetDiagClassId\x12+\n" + + "\x11inet_diag_sockopt\x18\xd2\x0f \x01(\rR\x0finetDiagSockopt\x12.\n" + + "\x13inet_diag_cgroup_id\x18\xd3\x0f \x01(\x04R\x10inetDiagCgroupId\"g\n" + "\bLocality\x12\x18\n" + "\x14LOCALITY_UNSPECIFIED\x10\x00\x12\x11\n" + "\rLOCALITY_SELF\x10\x01\x12\x19\n" + @@ -1935,7 +2033,7 @@ const file_xtcp_flat_record_v1_xtcp_flat_record_proto_rawDesc = "" + "\x1bCONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n" + "\x19CONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n" + "\x19CONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n" + - "\x19CONGESTION_ALGORITHM_BBR3\x10\a\"\x14\n" + + "\x19CONGESTION_ALGORITHM_BBR3\x10\aJ\x06\b\xad\x02\x10\xae\x02J\x06\b\xae\x02\x10\xaf\x02J\x06\b\xf3\a\x10\xf4\aJ\x06\b\xf4\a\x10\xf5\aJ\x06\b\xfa\a\x10\xfb\aJ\x06\b\xfb\a\x10\xfc\aJ\x06\b\xb7\x10\x10\xb8\x10R\x1dinet_diag_msg_socket_dest_asnR!inet_diag_msg_socket_next_hop_asnR'inet_diag_msg_socket_dest_network_ownerR\"inet_diag_msg_socket_dest_localityR\x1aenrich_socket_next_hop_asnR\x13tcp_info_send_scaleR\x12tcp_info_rcv_scaleR tcp_info_fast_open_client_failedR\x10tcp_info_rtt_varR\x10tcp_info_adv_mssR\x17tcp_info_not_sent_bytesR\x13sk_mem_info_rcv_bufR\x13sk_mem_info_snd_bufR\x12vegas_info_rtt_cntR\x12vegas_info_min_rttR\x1bcongestion_algorithm_stringR\x19congestion_algorithm_enumR\x0ftype_of_serviceR\rtraffic_classR\x0eshutdown_stateR\bclass_idR\bsock_optR\ac_group\"\x14\n" + "\x12FlatRecordsRequest\"d\n" + "\x13FlatRecordsResponse\x12M\n" + "\x10xtcp_flat_record\x18\x01 \x01(\v2#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n" + @@ -1973,8 +2071,8 @@ var file_xtcp_flat_record_v1_xtcp_flat_record_proto_goTypes = []any{ } var file_xtcp_flat_record_v1_xtcp_flat_record_proto_depIdxs = []int32{ 3, // 0: xtcp_flat_record.v1.Envelope.row:type_name -> xtcp_flat_record.v1.XtcpFlatRecord - 0, // 1: xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_msg_socket_dest_locality:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.Locality - 1, // 2: xtcp_flat_record.v1.XtcpFlatRecord.congestion_algorithm_enum:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm + 0, // 1: xtcp_flat_record.v1.XtcpFlatRecord.enrich_socket_dest_locality:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.Locality + 1, // 2: xtcp_flat_record.v1.XtcpFlatRecord.inet_diag_cong_enum:type_name -> xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithm 3, // 3: xtcp_flat_record.v1.FlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord 3, // 4: xtcp_flat_record.v1.PollFlatRecordsResponse.xtcp_flat_record:type_name -> xtcp_flat_record.v1.XtcpFlatRecord 4, // 5: xtcp_flat_record.v1.XTCPFlatRecordService.FlatRecords:input_type -> xtcp_flat_record.v1.FlatRecordsRequest diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record_grpc.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record_grpc.pb.go index 6be729d..9dd6713 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record_grpc.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record_grpc.pb.go @@ -1,20 +1,52 @@ // // xTCP - eXport TCP Inet Diagnostic messages // -// These are all the structs relating to the TCP diagnotic module in the kernel +// XtcpFlatRecord is one flat row per socket: daemon metadata, daemon-computed +// enrichment, and the raw kernel inet_diag payload (struct inet_diag_msg + every +// INET_DIAG_* extension xtcp requests). Protobuf's smallest scalar is 32 bits, +// so kernel __u8/__u16 members are widened to uint32; the trailing comment on +// every payload field records the kernel member and its C type. // -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 +// Kernel source of truth (Linux 7.2-rc, include/uapi/linux/): +// inet_diag.h struct inet_diag_msg, inet_diag_sockid, inet_diag_meminfo, +// tcpvegas_info, tcp_dctcp_info, tcp_bbr_info, inet_diag_sockopt, +// enum INET_DIAG_* (extension attribute ids) +// tcp.h struct tcp_info +// sock_diag.h enum SK_MEMINFO_* +// net/ipv4/inet_diag.c inet_sk_diag_fill / inet_diag_msg_attrs_fill (what +// each nla_put_* actually carries) // -// There are links to the kernel source showing where the struct came from. +// --------------------------------------------------------------------------- +// FIELD-NUMBER ALLOCATION POLICY (v2, 2026-09) +// --------------------------------------------------------------------------- +// 1-299 metadata daemon identity, time, namespace, container, labels, +// bookkeeping, per-uplink host topology (one block each) +// 300-399 enrichment daemon-COMPUTED fields (NOT read from the kernel): +// 300-309 socket-side, 310-349 destination-side, +// 350-389 source-side (future), 390-399 spare +// 400-999 spare unallocated; open a new metadata/enrichment block here +// 1000+ payload raw kernel inet_diag data, ONE hundred-block per kernel +// struct / INET_DIAG_* extension (1000 inet_diag_msg, +// 1100 meminfo, 1200 tcp_info, 1300 cong, 1400 tos/tclass, +// 1500 skmeminfo, 1600 shutdown, 1700 vegas, 1800 dctcp, +// 1900 bbr, 2000 class_id/sockopt/cgroup_id; next free +// block = 2100) +// Wire cost: tags 1-15 = 1 byte, 16-2047 = 2 bytes, 2048+ = 3 bytes. Every field +// here is <= 2047. Fill free slots inside an existing block before opening one +// above 2047. +// Naming: payload fields are _ using the kernel's +// exact spelling (tcp_info_rttvar, not rtt_var). Attributes with no struct take +// the lowercased INET_DIAG_* name (inet_diag_tos). The six inet_diag_msg_socket_* +// sockid fields keep their descriptive names (heavily used downstream). +// Evolution: never reuse a number or a name (add both to `reserved`); any rename +// or renumber is a new record epoch -> bump XtcpFlatRecordSchemaVersion +// (pkg/xtcp/schema_version.go) and add the matching ClickHouse _vN table + MV +// (build/containers/clickhouse/initdb.d/sql/). Adding a field in a free slot is +// NOT an epoch bump. ClickHouse maps columns by field NAME; Parquet by NAME; +// the csv/tsv marshallers by DECLARATION ORDER; gRPC clients are built from +// gen/go in this repo. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder - -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto - // https://protobuf.dev/programming-guides/encoding/#structure // Code generated by protoc-gen-go-grpc. DO NOT EDIT. diff --git a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go index 7d03406..4084ff8 100644 --- a/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go +++ b/gen/go/xtcp_flat_record/xtcp_flat_record_vtproto.pb.go @@ -93,24 +93,22 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.CGroup != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CGroup)) + if m.InetDiagCgroupId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagCgroupId)) i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x83 + dAtA[i] = 0x7d i-- - dAtA[i] = 0xb8 + dAtA[i] = 0x98 } - if m.SockOpt != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SockOpt)) + if m.InetDiagSockopt != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagSockopt)) i-- dAtA[i] = 0x7d i-- dAtA[i] = 0x90 } - if m.ClassId != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClassId)) + if m.InetDiagClassId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagClassId)) i-- dAtA[i] = 0x7d i-- @@ -186,8 +184,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xc8 } - if m.VegasInfoMinRtt != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VegasInfoMinRtt)) + if m.VegasInfoMinrtt != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VegasInfoMinrtt)) i-- dAtA[i] = 0x6a i-- @@ -200,8 +198,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xb8 } - if m.VegasInfoRttCnt != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VegasInfoRttCnt)) + if m.VegasInfoRttcnt != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VegasInfoRttcnt)) i-- dAtA[i] = 0x6a i-- @@ -214,8 +212,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xa8 } - if m.ShutdownState != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ShutdownState)) + if m.InetDiagShutdown != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagShutdown)) i-- dAtA[i] = 0x64 i-- @@ -256,8 +254,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0x88 } - if m.SkMemInfoSndBuf != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SkMemInfoSndBuf)) + if m.SkMemInfoSndbuf != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SkMemInfoSndbuf)) i-- dAtA[i] = 0x5e i-- @@ -270,8 +268,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf8 } - if m.SkMemInfoRcvBuf != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SkMemInfoRcvBuf)) + if m.SkMemInfoRcvbuf != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SkMemInfoRcvbuf)) i-- dAtA[i] = 0x5d i-- @@ -284,31 +282,31 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xe8 } - if m.TrafficClass != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TrafficClass)) + if m.InetDiagTclass != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagTclass)) i-- dAtA[i] = 0x57 i-- dAtA[i] = 0xd0 } - if m.TypeOfService != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TypeOfService)) + if m.InetDiagTos != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagTos)) i-- dAtA[i] = 0x57 i-- dAtA[i] = 0xc8 } - if m.CongestionAlgorithmEnum != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CongestionAlgorithmEnum)) + if m.InetDiagCongEnum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagCongEnum)) i-- dAtA[i] = 0x51 i-- dAtA[i] = 0xa8 } - if len(m.CongestionAlgorithmString) > 0 { - i -= len(m.CongestionAlgorithmString) - copy(dAtA[i:], m.CongestionAlgorithmString) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CongestionAlgorithmString))) + if len(m.InetDiagCong) > 0 { + i -= len(m.InetDiagCong) + copy(dAtA[i:], m.InetDiagCong) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InetDiagCong))) i-- dAtA[i] = 0x51 i-- @@ -454,8 +452,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf0 } - if m.TcpInfoNotSentBytes != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoNotSentBytes)) + if m.TcpInfoNotsentBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoNotsentBytes)) i-- dAtA[i] = 0x4d i-- @@ -531,8 +529,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0x98 } - if m.TcpInfoAdvMss != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoAdvMss)) + if m.TcpInfoAdvmss != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoAdvmss)) i-- dAtA[i] = 0x4d i-- @@ -552,8 +550,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0x80 } - if m.TcpInfoRttVar != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoRttVar)) + if m.TcpInfoRttvar != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoRttvar)) i-- dAtA[i] = 0x4c i-- @@ -671,8 +669,8 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xf8 } - if m.TcpInfoFastOpenClientFailed != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoFastOpenClientFailed)) + if m.TcpInfoFastopenClientFail != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoFastopenClientFail)) i-- dAtA[i] = 0x4b i-- @@ -685,15 +683,15 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xc8 } - if m.TcpInfoRcvScale != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoRcvScale)) + if m.TcpInfoRcvWscale != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoRcvWscale)) i-- dAtA[i] = 0x4b i-- dAtA[i] = 0xc0 } - if m.TcpInfoSendScale != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoSendScale)) + if m.TcpInfoSndWscale != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TcpInfoSndWscale)) i-- dAtA[i] = 0x4b i-- @@ -769,22 +767,6 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xe8 } - if m.InetDiagMsgSocketDestLocality != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgSocketDestLocality)) - i-- - dAtA[i] = 0x3f - i-- - dAtA[i] = 0xd8 - } - if len(m.InetDiagMsgSocketDestNetworkOwner) > 0 { - i -= len(m.InetDiagMsgSocketDestNetworkOwner) - copy(dAtA[i:], m.InetDiagMsgSocketDestNetworkOwner) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InetDiagMsgSocketDestNetworkOwner))) - i-- - dAtA[i] = 0x3f - i-- - dAtA[i] = 0xd2 - } if m.InetDiagMsgInode != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgInode)) i-- @@ -820,20 +802,6 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xa8 } - if m.InetDiagMsgSocketNextHopAsn != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgSocketNextHopAsn)) - i-- - dAtA[i] = 0x3f - i-- - dAtA[i] = 0xa0 - } - if m.InetDiagMsgSocketDestAsn != 0 { - i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgSocketDestAsn)) - i-- - dAtA[i] = 0x3f - i-- - dAtA[i] = 0x98 - } if m.InetDiagMsgSocketCookie != 0 { i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InetDiagMsgSocketCookie)) i-- @@ -908,6 +876,61 @@ func (m *XtcpFlatRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0xc8 } + if len(m.EnrichSocketDestNetworkOwner) > 0 { + i -= len(m.EnrichSocketDestNetworkOwner) + copy(dAtA[i:], m.EnrichSocketDestNetworkOwner) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EnrichSocketDestNetworkOwner))) + i-- + dAtA[i] = 0x14 + i-- + dAtA[i] = 0x92 + } + if m.EnrichSocketDestNextHopAsn != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnrichSocketDestNextHopAsn)) + i-- + dAtA[i] = 0x14 + i-- + dAtA[i] = 0x88 + } + if m.EnrichSocketDestAsn != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnrichSocketDestAsn)) + i-- + dAtA[i] = 0x14 + i-- + dAtA[i] = 0x80 + } + if len(m.EnrichSocketDestEgressIfname) > 0 { + i -= len(m.EnrichSocketDestEgressIfname) + copy(dAtA[i:], m.EnrichSocketDestEgressIfname) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EnrichSocketDestEgressIfname))) + i-- + dAtA[i] = 0x13 + i-- + dAtA[i] = 0xc2 + } + if m.EnrichSocketDestEgressIfindex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnrichSocketDestEgressIfindex)) + i-- + dAtA[i] = 0x13 + i-- + dAtA[i] = 0xb8 + } + if m.EnrichSocketDestLocality != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EnrichSocketDestLocality)) + i-- + dAtA[i] = 0x13 + i-- + dAtA[i] = 0xb0 + } + if len(m.EnrichSocketInterfaceName) > 0 { + i -= len(m.EnrichSocketInterfaceName) + copy(dAtA[i:], m.EnrichSocketInterfaceName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EnrichSocketInterfaceName))) + i-- + dAtA[i] = 0x12 + i-- + dAtA[i] = 0xe2 + } if len(m.Uplink2LldpPortDescr) > 0 { i -= len(m.Uplink2LldpPortDescr) copy(dAtA[i:], m.Uplink2LldpPortDescr) @@ -1599,6 +1622,30 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } + l = len(m.EnrichSocketInterfaceName) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EnrichSocketDestLocality != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnrichSocketDestLocality)) + } + if m.EnrichSocketDestEgressIfindex != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnrichSocketDestEgressIfindex)) + } + l = len(m.EnrichSocketDestEgressIfname) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.EnrichSocketDestAsn != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnrichSocketDestAsn)) + } + if m.EnrichSocketDestNextHopAsn != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EnrichSocketDestNextHopAsn)) + } + l = len(m.EnrichSocketDestNetworkOwner) + if l > 0 { + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } if m.InetDiagMsgFamily != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgFamily)) } @@ -1631,12 +1678,6 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.InetDiagMsgSocketCookie != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgSocketCookie)) } - if m.InetDiagMsgSocketDestAsn != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgSocketDestAsn)) - } - if m.InetDiagMsgSocketNextHopAsn != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgSocketNextHopAsn)) - } if m.InetDiagMsgExpires != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgExpires)) } @@ -1652,13 +1693,6 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.InetDiagMsgInode != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgInode)) } - l = len(m.InetDiagMsgSocketDestNetworkOwner) - if l > 0 { - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) - } - if m.InetDiagMsgSocketDestLocality != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagMsgSocketDestLocality)) - } if m.MemInfoRmem != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.MemInfoRmem)) } @@ -1689,17 +1723,17 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.TcpInfoOptions != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoOptions)) } - if m.TcpInfoSendScale != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoSendScale)) + if m.TcpInfoSndWscale != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoSndWscale)) } - if m.TcpInfoRcvScale != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRcvScale)) + if m.TcpInfoRcvWscale != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRcvWscale)) } if m.TcpInfoDeliveryRateAppLimited != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoDeliveryRateAppLimited)) } - if m.TcpInfoFastOpenClientFailed != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoFastOpenClientFailed)) + if m.TcpInfoFastopenClientFail != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoFastopenClientFail)) } if m.TcpInfoRto != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRto)) @@ -1749,8 +1783,8 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.TcpInfoRtt != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRtt)) } - if m.TcpInfoRttVar != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRttVar)) + if m.TcpInfoRttvar != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoRttvar)) } if m.TcpInfoSndSsthresh != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoSndSsthresh)) @@ -1758,8 +1792,8 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.TcpInfoSndCwnd != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoSndCwnd)) } - if m.TcpInfoAdvMss != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoAdvMss)) + if m.TcpInfoAdvmss != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoAdvmss)) } if m.TcpInfoReordering != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoReordering)) @@ -1791,8 +1825,8 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.TcpInfoSegsIn != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoSegsIn)) } - if m.TcpInfoNotSentBytes != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoNotSentBytes)) + if m.TcpInfoNotsentBytes != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoNotsentBytes)) } if m.TcpInfoMinRtt != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoMinRtt)) @@ -1854,30 +1888,30 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.TcpInfoTotalRtoTime != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.TcpInfoTotalRtoTime)) } - l = len(m.CongestionAlgorithmString) + l = len(m.InetDiagCong) if l > 0 { n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.CongestionAlgorithmEnum != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.CongestionAlgorithmEnum)) + if m.InetDiagCongEnum != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagCongEnum)) } - if m.TypeOfService != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TypeOfService)) + if m.InetDiagTos != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagTos)) } - if m.TrafficClass != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.TrafficClass)) + if m.InetDiagTclass != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagTclass)) } if m.SkMemInfoRmemAlloc != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoRmemAlloc)) } - if m.SkMemInfoRcvBuf != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoRcvBuf)) + if m.SkMemInfoRcvbuf != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoRcvbuf)) } if m.SkMemInfoWmemAlloc != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoWmemAlloc)) } - if m.SkMemInfoSndBuf != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoSndBuf)) + if m.SkMemInfoSndbuf != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoSndbuf)) } if m.SkMemInfoFwdAlloc != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoFwdAlloc)) @@ -1894,20 +1928,20 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.SkMemInfoDrops != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.SkMemInfoDrops)) } - if m.ShutdownState != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.ShutdownState)) + if m.InetDiagShutdown != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagShutdown)) } if m.VegasInfoEnabled != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoEnabled)) } - if m.VegasInfoRttCnt != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoRttCnt)) + if m.VegasInfoRttcnt != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoRttcnt)) } if m.VegasInfoRtt != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoRtt)) } - if m.VegasInfoMinRtt != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoMinRtt)) + if m.VegasInfoMinrtt != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.VegasInfoMinrtt)) } if m.DctcpInfoEnabled != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.DctcpInfoEnabled)) @@ -1939,14 +1973,14 @@ func (m *XtcpFlatRecord) SizeVT() (n int) { if m.BbrInfoCwndGain != 0 { n += 2 + protohelpers.SizeOfVarint(uint64(m.BbrInfoCwndGain)) } - if m.ClassId != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.ClassId)) + if m.InetDiagClassId != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagClassId)) } - if m.SockOpt != 0 { - n += 2 + protohelpers.SizeOfVarint(uint64(m.SockOpt)) + if m.InetDiagSockopt != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagSockopt)) } - if m.CGroup != 0 { - n += 3 + protohelpers.SizeOfVarint(uint64(m.CGroup)) + if m.InetDiagCgroupId != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.InetDiagCgroupId)) } n += len(m.unknownFields) return n @@ -3321,6 +3355,178 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } m.Uplink2LldpPortDescr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 300: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketInterfaceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EnrichSocketInterfaceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 310: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestLocality", wireType) + } + m.EnrichSocketDestLocality = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EnrichSocketDestLocality |= XtcpFlatRecord_Locality(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 311: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestEgressIfindex", wireType) + } + m.EnrichSocketDestEgressIfindex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EnrichSocketDestEgressIfindex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 312: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestEgressIfname", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EnrichSocketDestEgressIfname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 320: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestAsn", wireType) + } + m.EnrichSocketDestAsn = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EnrichSocketDestAsn |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 321: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestNextHopAsn", wireType) + } + m.EnrichSocketDestNextHopAsn = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EnrichSocketDestNextHopAsn |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 322: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EnrichSocketDestNetworkOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EnrichSocketDestNetworkOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 1001: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgFamily", wireType) @@ -3541,44 +3747,6 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { break } } - case 1011: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketDestAsn", wireType) - } - m.InetDiagMsgSocketDestAsn = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.InetDiagMsgSocketDestAsn |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 1012: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketNextHopAsn", wireType) - } - m.InetDiagMsgSocketNextHopAsn = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.InetDiagMsgSocketNextHopAsn |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } case 1013: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgExpires", wireType) @@ -3674,57 +3842,6 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { break } } - case 1018: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketDestNetworkOwner", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InetDiagMsgSocketDestNetworkOwner = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 1019: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field InetDiagMsgSocketDestLocality", wireType) - } - m.InetDiagMsgSocketDestLocality = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.InetDiagMsgSocketDestLocality |= XtcpFlatRecord_Locality(b&0x7F) << shift - if b < 0x80 { - break - } - } case 1101: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MemInfoRmem", wireType) @@ -3917,9 +4034,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1207: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoSendScale", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoSndWscale", wireType) } - m.TcpInfoSendScale = 0 + m.TcpInfoSndWscale = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3929,16 +4046,16 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoSendScale |= uint32(b&0x7F) << shift + m.TcpInfoSndWscale |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 1208: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoRcvScale", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoRcvWscale", wireType) } - m.TcpInfoRcvScale = 0 + m.TcpInfoRcvWscale = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3948,7 +4065,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoRcvScale |= uint32(b&0x7F) << shift + m.TcpInfoRcvWscale |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -3974,9 +4091,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1210: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoFastOpenClientFailed", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoFastopenClientFail", wireType) } - m.TcpInfoFastOpenClientFailed = 0 + m.TcpInfoFastopenClientFail = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -3986,7 +4103,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoFastOpenClientFailed |= uint32(b&0x7F) << shift + m.TcpInfoFastopenClientFail |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -4297,9 +4414,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1231: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoRttVar", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoRttvar", wireType) } - m.TcpInfoRttVar = 0 + m.TcpInfoRttvar = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4309,7 +4426,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoRttVar |= uint32(b&0x7F) << shift + m.TcpInfoRttvar |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -4354,9 +4471,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1234: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoAdvMss", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoAdvmss", wireType) } - m.TcpInfoAdvMss = 0 + m.TcpInfoAdvmss = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4366,7 +4483,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoAdvMss |= uint32(b&0x7F) << shift + m.TcpInfoAdvmss |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -4563,9 +4680,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1245: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoNotSentBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TcpInfoNotsentBytes", wireType) } - m.TcpInfoNotSentBytes = 0 + m.TcpInfoNotsentBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -4575,7 +4692,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TcpInfoNotSentBytes |= uint32(b&0x7F) << shift + m.TcpInfoNotsentBytes |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -4962,7 +5079,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1300: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CongestionAlgorithmString", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagCong", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4990,13 +5107,13 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CongestionAlgorithmString = string(dAtA[iNdEx:postIndex]) + m.InetDiagCong = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 1301: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CongestionAlgorithmEnum", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagCongEnum", wireType) } - m.CongestionAlgorithmEnum = 0 + m.InetDiagCongEnum = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5006,16 +5123,16 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CongestionAlgorithmEnum |= XtcpFlatRecord_CongestionAlgorithm(b&0x7F) << shift + m.InetDiagCongEnum |= XtcpFlatRecord_CongestionAlgorithm(b&0x7F) << shift if b < 0x80 { break } } case 1401: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TypeOfService", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagTos", wireType) } - m.TypeOfService = 0 + m.InetDiagTos = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5025,16 +5142,16 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TypeOfService |= uint32(b&0x7F) << shift + m.InetDiagTos |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 1402: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TrafficClass", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagTclass", wireType) } - m.TrafficClass = 0 + m.InetDiagTclass = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5044,7 +5161,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TrafficClass |= uint32(b&0x7F) << shift + m.InetDiagTclass |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5070,9 +5187,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1502: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SkMemInfoRcvBuf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SkMemInfoRcvbuf", wireType) } - m.SkMemInfoRcvBuf = 0 + m.SkMemInfoRcvbuf = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5082,7 +5199,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SkMemInfoRcvBuf |= uint32(b&0x7F) << shift + m.SkMemInfoRcvbuf |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5108,9 +5225,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1504: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SkMemInfoSndBuf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SkMemInfoSndbuf", wireType) } - m.SkMemInfoSndBuf = 0 + m.SkMemInfoSndbuf = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5120,7 +5237,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SkMemInfoSndBuf |= uint32(b&0x7F) << shift + m.SkMemInfoSndbuf |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5222,9 +5339,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1600: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ShutdownState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagShutdown", wireType) } - m.ShutdownState = 0 + m.InetDiagShutdown = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5234,7 +5351,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ShutdownState |= uint32(b&0x7F) << shift + m.InetDiagShutdown |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5260,9 +5377,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1702: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field VegasInfoRttCnt", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field VegasInfoRttcnt", wireType) } - m.VegasInfoRttCnt = 0 + m.VegasInfoRttcnt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5272,7 +5389,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.VegasInfoRttCnt |= uint32(b&0x7F) << shift + m.VegasInfoRttcnt |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5298,9 +5415,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 1704: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field VegasInfoMinRtt", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field VegasInfoMinrtt", wireType) } - m.VegasInfoMinRtt = 0 + m.VegasInfoMinrtt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5310,7 +5427,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.VegasInfoMinRtt |= uint32(b&0x7F) << shift + m.VegasInfoMinrtt |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5507,9 +5624,9 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } case 2001: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagClassId", wireType) } - m.ClassId = 0 + m.InetDiagClassId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5519,16 +5636,16 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ClassId |= uint32(b&0x7F) << shift + m.InetDiagClassId |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2002: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SockOpt", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagSockopt", wireType) } - m.SockOpt = 0 + m.InetDiagSockopt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5538,16 +5655,16 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SockOpt |= uint32(b&0x7F) << shift + m.InetDiagSockopt |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 2103: + case 2003: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CGroup", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InetDiagCgroupId", wireType) } - m.CGroup = 0 + m.InetDiagCgroupId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -5557,7 +5674,7 @@ func (m *XtcpFlatRecord) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CGroup |= uint64(b&0x7F) << shift + m.InetDiagCgroupId |= uint64(b&0x7F) << shift if b < 0x80 { break } diff --git a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json index aab79a8..29e9f00 100644 --- a/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json +++ b/gen/openapi/xtcp_config/v1/xtcp_config.swagger.json @@ -430,6 +430,11 @@ "type": "string", "title": "Poll timeout per name space\nMust be less than the poll frequency" }, + "pollJitterPct": { + "type": "integer", + "format": "int64", + "description": "Maximum poll-schedule jitter as a percent of poll_frequency, applied to\nboth the startup delay before the first poll and each subsequent tick.\n0 disables (immediate first poll, fixed interval). Default 20. See\ndocs/design-jitter-and-backoff.md." + }, "maxLoops": { "type": "string", "format": "uint64", @@ -460,6 +465,37 @@ "format": "int64", "title": "netlinker packetSize multiplier. buffer size = packetSize * packetSizeMply" }, + "modulus": { + "type": "string", + "format": "uint64", + "title": "modulus. Report every X socket diag messages to output" + }, + "enabledDeserializers": { + "$ref": "#/definitions/v1EnabledDeserializers", + "description": "Which INET_DIAG_* extension deserializers run (keyed by short name:\ninfo, skmem, cong, tos, tc, shut, vegas, dctcp, bbr, classid, sockopt,\ncgroup, meminfo). Unset = daemon defaults." + }, + "ioUring": { + "type": "boolean", + "description": "When true, route netlink reads and raw-socket destination writes\nthrough an io_uring ring per Netlinker. Requires Linux 6.1+.\nLibrary-backed destinations (kafka, nsq, nats, valkey) ignore this\nflag — they continue to use their own client sockets unchanged." + }, + "ioUringRecvBatchSize": { + "type": "integer", + "format": "int64", + "description": "Number of recvmsg SQEs kept in flight per Netlinker ring. Higher\nvalues reduce io_uring_enter syscalls per dump cycle on hosts with\nmany sockets, at the cost of more pinned buffers from packet pool.\nIgnored unless io_uring=true. Default 64." + }, + "ioUringCqeBatchSize": { + "type": "integer", + "format": "int64", + "description": "Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise\nuserland loop overhead but increase scheduling latency for the\nnetlinker goroutine. Ignored unless io_uring=true. Default 128." + }, + "reconcileFrequency": { + "type": "string", + "description": "Period of the background namespace-reconcile ticker (Method B /proc scan\nthat converges the tracked namespace set). With reconcile_before_poll the\nPoller reconciles every cycle and is the real discovery mechanism, so this\nbackground pass is an occasional safety-net expected to find nothing\n(mapReconciler dels/stores stay 0) — the default is deliberately long (6h)\nso operators can confirm from the counters that it is redundant. It still\nmatters when the poller is idle or disabled. 0 disables the background\nticker entirely (the startup reconcile still runs once)." + }, + "reconcileBeforePoll": { + "type": "boolean", + "description": "Run a namespace reconcile immediately before each poll cycle, so a\nnamespace that appeared since the last cycle is entered and gets a socket\nwithin ~1 poll interval instead of waiting for the background ticker. Ties\ndiscovery cadence to poll cadence; the /proc scan is zero-allocation and\nmutex-serialized with the background reconciler. Default true." + }, "writeFiles": { "type": "integer", "format": "int64", @@ -469,15 +505,32 @@ "type": "string", "title": "Write files path" }, - "modulus": { + "destWriteFiles": { + "type": "integer", + "format": "int64", + "title": "Write marshalled data to dest_write_files number of files ( to allow debugging of the serialization )\nxtcp will capture this many examples of the marshalled data\nThis is PER poller" + }, + "debugLevel": { + "type": "integer", + "format": "int64", + "title": "DebugLevel" + }, + "dest": { "type": "string", - "format": "uint64", - "title": "modulus. Report every X socket diag messages to output" + "description": "kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150,\nnats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:,\nunix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or\nunixgram:/path/to/sock (SOCK_DGRAM, one record per datagram).\nmax_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the\nhttp(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES\nand S3 endpoints the INSERT query + FORMAT + format_schema + auth query\nparams routinely run ~150+ chars, which the old 128 cap rejected." }, "marshalTo": { "type": "string", "title": "Marshalling of the exported data (protobufList,json,prototext)" }, + "csvColumns": { + "type": "string", + "description": "Comma-separated subset of XtcpFlatRecord json field names selecting\nwhich columns the csv/tsv marshallers emit (e.g.\n\"hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt\").\nEmpty = all fields. Ignored by non-tabular marshallers." + }, + "xtcpProtoFile": { + "type": "string", + "description": "XtcpProtoFile — path of the xtcp_flat_record.proto the daemon reads at\nstartup and POSTs to the Kafka schema registry (kafka_schema_url)." + }, "envelopeFlushThresholdBytes": { "type": "integer", "format": "int64", @@ -488,6 +541,18 @@ "format": "int64", "description": "Soft cap on the in-flight envelope's row count. When the envelope\nreaches this many rows, deserialize.go triggers an early mid-poll\nflush. Cheaper than the byte cap (no proto.Size walk on the hot\npath) and more predictable for operators reasoning about batch\nsize directly.\n\n0 = use the daemon's compile-time default\n(EnvelopeFlushThresholdRowsCst, currently 10000 — chosen to align\nwith the ClickHouse kafka_max_rows_per_message setting so a\nproduced envelope never forces the consumer to split it)." }, + "topic": { + "type": "string", + "title": "Kafka or NSQ topic" + }, + "kafkaSchemaUrl": { + "type": "string", + "title": "Kafka schema registry url" + }, + "kafkaProduceTimeout": { + "type": "string", + "title": "Kafka Produce context timeout. Use 0 for no context timeout\nRecommend a small timeout, like 1-2 seconds\nkgo seems to have a bug, because the timeout is always expired" + }, "kafkaCompression": { "type": "string", "description": "Kafka producer-batch compression codec. franz-go picks one codec\nfrom the supplied preference list that the broker advertises.\nBoth Redpanda and ClickHouse (via librdkafka on its Kafka engine)\ndecompress all standard codecs transparently — no consumer-side\nconfig is needed regardless of which codec is chosen here.\n\nValid values:\n \"\" or \"auto\" → preference list [zstd, lz4, snappy, none] —\n modern brokers (Redpanda, Kafka 2.1+) end up\n on zstd; older brokers fall back through the list\n \"zstd\" → force ZStandard (best ratio, modern default)\n \"lz4\" → force LZ4 (fast, low CPU)\n \"snappy\" → force Snappy (legacy, broad compat)\n \"gzip\" → force Gzip (highest CPU; legacy clients)\n \"none\" → no compression on the wire\n\nPick \"lz4\" if xtcp2 is CPU-bound on the producer side; pick\n\"zstd\" (the default) if Kafka throughput / disk usage matters more." @@ -496,6 +561,10 @@ "type": "string", "description": "S3 endpoint URL, e.g. \"http://127.0.0.1:9000\" (MinIO) or\n\"https://s3.amazonaws.com\" (AWS). May be empty if -dest carries\nit via the s3parquet:\u003cendpoint\u003e form." }, + "s3Region": { + "type": "string", + "description": "S3 region. Required by some S3 implementations even when talking\nto a single-region MinIO. Default \"us-east-1\" when blank." + }, "s3Bucket": { "type": "string", "description": "Required when -dest s3parquet. Bucket must already exist on the\nendpoint; the daemon does not auto-create." @@ -512,66 +581,45 @@ "type": "string", "description": "Required when -dest s3parquet. Picked up from AWS_SECRET_ACCESS_KEY\nenv if blank. Never logged." }, - "s3ParquetFlushThresholdBytes": { - "type": "integer", - "format": "int64", - "description": "Soft cap on the in-memory Parquet builder's accumulated\nuncompressed row bytes before the worker finalizes the file and\nuploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst).\nOperators tune down for faster file rotation (more S3 PUTs,\nsmaller per-file query latency) or up for fewer larger files\n(better compression ratio, more memory)." - }, - "s3Region": { - "type": "string", - "description": "S3 region. Required by some S3 implementations even when talking\nto a single-region MinIO. Default \"us-east-1\" when blank." - }, "s3SkipBucketProbe": { "type": "boolean", "description": "Skip the startup S3 BucketExists probe. The probe issues a\nHeadBucket, which requires the s3:ListBucket permission. Set true\nwhen the upload credential is deliberately scoped to s3:PutObject\nonly (write-only key, e.g. a baked deployment credential) so the\ndaemon can start without list permission. Default false keeps the\nfail-fast probe for normal deployments." }, - "pyroscopeUrl": { - "type": "string", - "description": "Pyroscope continuous-profiling server URL (e.g.\nhttp://127.0.0.1:4040). When set, the daemon streams CPU,\nmemory, goroutine, mutex, and block profiles to that endpoint.\nEmpty disables the agent — no overhead in production runs that\ndon't need it. Operators bring up a Pyroscope OSS server (or\nGrafana Cloud Pyroscope) and point xtcp2 at it for live profile\ndata without restarts." + "s3ParquetFlushThresholdBytes": { + "type": "integer", + "format": "int64", + "description": "Soft cap on the in-memory Parquet builder's accumulated\nuncompressed row bytes before the worker finalizes the file and\nuploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst).\nOperators tune down for faster file rotation (more S3 PUTs,\nsmaller per-file query latency) or up for fewer larger files\n(better compression ratio, more memory)." }, - "pyroscopeAppName": { + "s3FlushInterval": { "type": "string", - "description": "Application name registered with the Pyroscope server (the\n\"application\" facet in the Pyroscope UI). Empty → \"xtcp2\".\nSet per fleet/role for multi-host environments\n(e.g. \"xtcp2.prod.iad\", \"xtcp2.staging.fra\")." + "description": "s3parquet staleness ceiling: force-flush the in-memory Parquet object\nafter this long even if it hasn't reached the byte cap, bounding upload\nlatency for low-volume hosts. 0 = derive as max(poll_frequency, 30m)." }, - "pyroscopeSampleHz": { + "s3FlushJitterPct": { "type": "integer", "format": "int64", - "description": "CPU profile sampling rate in Hz. Default 100. The Pyroscope\nagent uses this to call runtime.SetCPUProfileRate at startup." + "description": "Maximum jitter as a percent of s3_flush_interval, applied to the first\ntimed flush and each interval so the fleet doesn't ceiling-flush in\nlockstep. 0 disables. Default 20." }, - "pyroscopeUploadIntervalSec": { + "s3FlushThresholdJitterPct": { "type": "integer", "format": "int64", - "description": "Profile upload interval (seconds between batched profile\npushes). Default 15 s." - }, - "dest": { - "type": "string", - "description": "kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150,\nnats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:,\nunix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or\nunixgram:/path/to/sock (SOCK_DGRAM, one record per datagram).\nmax_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the\nhttp(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES\nand S3 endpoints the INSERT query + FORMAT + format_schema + auth query\nparams routinely run ~150+ chars, which the old 128 cap rejected." + "description": "Per-object downward jitter as a percent of the s3parquet byte cap: each\nobject finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the\nsize-cap upload path even under uniform load. Downward-only, so an\nobject never exceeds the in-memory byte bound. 0 disables. Default 20." }, - "destWriteFiles": { + "s3UploadMaxAttempts": { "type": "integer", "format": "int64", - "title": "Write marhselled data to writeFiles number of files ( to allow debugging of the serialization )\nxtcp will capture this many examples of the marshalled data\nThis is PER poller" - }, - "topic": { - "type": "string", - "title": "Kafka or NSQ topic" + "description": "Maximum S3 upload attempts (original + retries) before dropping the\nobject. Retries use full-jitter exponential backoff. Default 10." }, - "xtcpProtoFile": { + "s3UploadBackoffCap": { "type": "string", - "title": "XtcpProtoFile" + "description": "Cap on a single upload retry's backoff window (full jitter draws in\n[0, window], window grows exponentially up to this cap). 0 = derive as\nclamp(poll_frequency/10, 1s, 1h)." }, - "kafkaSchemaUrl": { + "hostname": { "type": "string", - "title": "Kafka schema registry url" + "description": "Hostname override. When empty the daemon uses os.Hostname(); set this to\nstamp an explicit hostname on records — required in containers, where\nos.Hostname() returns the container id, not the host. Set via -hostname\nflag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the\ncontainer id)." }, - "kafkaProduceTimeout": { + "location": { "type": "string", - "title": "Kafka Produce context timeout. Use 0 for no context timeout\nRecommend a small timeout, like 1-2 seconds\nkgo seems to have a bug, because the timeout is always expired" - }, - "debugLevel": { - "type": "integer", - "format": "int64", - "title": "DebugLevel" + "description": "Deployment grouping / facility this daemon runs in (data center, PoP,\nregion, site, …). Generic; stamped on every record's `location` field.\nSet via -location flag or LOCATION env." }, "label": { "type": "string", @@ -581,22 +629,10 @@ "type": "string", "title": "Tag applied to the protobuf" }, - "location": { - "type": "string", - "description": "Deployment grouping / facility this daemon runs in (data center, PoP,\nregion, site, …). Generic; stamped on every record's `location` field.\nSet via -location flag or LOCATION env." - }, - "hostname": { - "type": "string", - "description": "Hostname override. When empty the daemon uses os.Hostname(); set this to\nstamp an explicit hostname on records — required in containers, where\nos.Hostname() returns the container id, not the host. Set via -hostname\nflag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the\ncontainer id)." - }, "daemonVersion": { "type": "string", "description": "Daemon build provenance stamped on every record's `daemon_version` field\n(git commit / date / version). Populated by the daemon from -ldflags build\nvars, not a user flag; informational only (debugging which binary produced a\nrow). See XtcpFlatRecord.daemon_version." }, - "resolveContainerId": { - "type": "boolean", - "description": "Resolve each socket's owning container id from its cgroup (sets the\nrecord's container_id / container_runtime). Set via -resolveContainerId\nflag or CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it\nand run --cgroupns=host in a container)." - }, "ipv4Ttl": { "type": "integer", "format": "int64", @@ -612,62 +648,27 @@ "format": "int64", "title": "GRPC listening port" }, - "enabledDeserializers": { - "$ref": "#/definitions/v1EnabledDeserializers" - }, - "ioUring": { - "type": "boolean", - "description": "When true, route netlink reads and raw-socket destination writes\nthrough an io_uring ring per Netlinker. Requires Linux 6.1+.\nLibrary-backed destinations (kafka, nsq, nats, valkey) ignore this\nflag — they continue to use their own client sockets unchanged." - }, - "ioUringRecvBatchSize": { - "type": "integer", - "format": "int64", - "description": "Number of recvmsg SQEs kept in flight per Netlinker ring. Higher\nvalues reduce io_uring_enter syscalls per dump cycle on hosts with\nmany sockets, at the cost of more pinned buffers from packet pool.\nIgnored unless io_uring=true. Default 64." - }, - "ioUringCqeBatchSize": { - "type": "integer", - "format": "int64", - "description": "Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise\nuserland loop overhead but increase scheduling latency for the\nnetlinker goroutine. Ignored unless io_uring=true. Default 128." - }, - "csvColumns": { + "pyroscopeUrl": { "type": "string", - "description": "Comma-separated subset of XtcpFlatRecord json field names selecting\nwhich columns the csv/tsv marshallers emit (e.g.\n\"hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt\").\nEmpty = all fields. Ignored by non-tabular marshallers." - }, - "pollJitterPct": { - "type": "integer", - "format": "int64", - "description": "Maximum poll-schedule jitter as a percent of poll_frequency, applied to\nboth the startup delay before the first poll and each subsequent tick.\n0 disables (immediate first poll, fixed interval). Default 20." + "description": "Pyroscope continuous-profiling server URL (e.g.\nhttp://127.0.0.1:4040). When set, the daemon streams CPU,\nmemory, goroutine, mutex, and block profiles to that endpoint.\nEmpty disables the agent — no overhead in production runs that\ndon't need it. Operators bring up a Pyroscope OSS server (or\nGrafana Cloud Pyroscope) and point xtcp2 at it for live profile\ndata without restarts." }, - "s3FlushInterval": { + "pyroscopeAppName": { "type": "string", - "description": "s3parquet staleness ceiling: force-flush the in-memory Parquet object\nafter this long even if it hasn't reached the byte cap, bounding upload\nlatency for low-volume hosts. 0 = derive as max(poll_frequency, 30m)." - }, - "s3FlushJitterPct": { - "type": "integer", - "format": "int64", - "description": "Maximum jitter as a percent of s3_flush_interval, applied to the first\ntimed flush and each interval so the fleet doesn't ceiling-flush in\nlockstep. 0 disables. Default 20." + "description": "Application name registered with the Pyroscope server (the\n\"application\" facet in the Pyroscope UI). Empty → \"xtcp2\".\nSet per fleet/role for multi-host environments\n(e.g. \"xtcp2.prod.iad\", \"xtcp2.staging.fra\")." }, - "s3FlushThresholdJitterPct": { + "pyroscopeSampleHz": { "type": "integer", "format": "int64", - "description": "Per-object downward jitter as a percent of the s3parquet byte cap: each\nobject finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the\nsize-cap upload path even under uniform load. Downward-only, so an\nobject never exceeds the in-memory byte bound. 0 disables. Default 20." + "description": "CPU profile sampling rate in Hz. Default 100. The Pyroscope\nagent uses this to call runtime.SetCPUProfileRate at startup." }, - "s3UploadMaxAttempts": { + "pyroscopeUploadIntervalSec": { "type": "integer", "format": "int64", - "description": "Maximum S3 upload attempts (original + retries) before dropping the\nobject. Retries use full-jitter exponential backoff. Default 10." - }, - "s3UploadBackoffCap": { - "type": "string", - "description": "Cap on a single upload retry's backoff window (full jitter draws in\n[0, window], window grows exponentially up to this cap). 0 = derive as\nclamp(poll_frequency/10, 1s, 1h)." - }, - "reconcileFrequency": { - "type": "string", - "description": "Period of the background namespace-reconcile ticker (Method B /proc scan\nthat converges the tracked namespace set). With reconcile_before_poll the\nPoller reconciles every cycle and is the real discovery mechanism, so this\nbackground pass is an occasional safety-net expected to find nothing\n(mapReconciler dels/stores stay 0) — the default is deliberately long (6h)\nso operators can confirm from the counters that it is redundant. It still\nmatters when the poller is idle or disabled. 0 disables the background\nticker entirely (the startup reconcile still runs once)." + "description": "Profile upload interval (seconds between batched profile\npushes). Default 15 s." }, - "reconcileBeforePoll": { + "resolveContainerId": { "type": "boolean", - "description": "Run a namespace reconcile immediately before each poll cycle, so a\nnamespace that appeared since the last cycle is entered and gets a socket\nwithin ~1 poll interval instead of waiting for the background ticker. Ties\ndiscovery cadence to poll cadence; the /proc scan is zero-allocation and\nmutex-serialized with the background reconciler. Default true." + "description": "-- container (200-209)\nResolve each socket's owning container id from its cgroup v2 id\n(inet_diag_cgroup_id, record field 2003) — sets the record's\ncontainer_id / container_runtime. Set via -resolveContainerId flag or\nCONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it and run\n--cgroupns=host in a container)." }, "enrichContainerEnable": { "type": "boolean", @@ -679,7 +680,7 @@ }, "enrichLldpEnable": { "type": "boolean", - "description": "Enrich per-uplink LLDP neighbor labels by reading the lldpd control socket\n(lldpd_socket_path) once at startup. Default false." + "description": "-- lldp (210-219)\nEnrich per-uplink LLDP neighbor labels by reading the lldpd control socket\n(lldpd_socket_path) once at startup. Default false." }, "lldpdSocketPath": { "type": "string", @@ -691,7 +692,7 @@ }, "enrichNicEnable": { "type": "boolean", - "description": "Enrich per-uplink NIC labels (driver/model/pci/speed/firmware) from sysfs +\nthe ethtool ioctl once at startup. Default false." + "description": "-- nic (220-229)\nEnrich per-uplink NIC labels (driver/model/pci/speed/firmware) from sysfs +\nthe ethtool ioctl once at startup. Default false." }, "uplinkCount": { "type": "integer", @@ -707,11 +708,11 @@ }, "populateNsid": { "type": "boolean", - "description": "Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for\nDocker/containerd namespaces. Default false." + "description": "-- nsid (230-239)\nPopulate nsid (record field 32) best-effort via RTM_GETNSID. Usually 0 for\nDocker/containerd namespaces. Default false." }, "enrichAsnEnable": { "type": "boolean", - "description": "Enrich the destination IP's ASN (field 1011) and network owner (field\n1018) by longest-prefix-matching it against the ipfeed-collector Parquet\nartifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when\nenabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter,\nand leaves both columns empty. Default false." + "description": "-- asn (240-244)\nEnrich the destination IP's ASN (record field 320) and network owner\n(322) by longest-prefix-matching it against the ipfeed-collector Parquet\nartifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when\nenabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter,\nand leaves both columns empty. Default false." }, "asnDbPath": { "type": "string", @@ -723,13 +724,14 @@ }, "enrichLocalityEnable": { "type": "boolean", - "description": "Classify the destination IP's locality (field 1019) — self /\nconnected-subnet / remote — from each monitored network namespace's local\naddresses + routing table, discovered via rtnetlink (pkg/localnet). Runs\nBEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal:\na per-namespace discovery failure just leaves that namespace's sockets\nunclassified. Default false." + "description": "-- locality (245-249)\nClassify the destination IP's locality (record field 310) — self /\nlocal-subnet / remote — from each monitored network namespace's local\naddresses + routing table, discovered via rtnetlink (pkg/localnet). Also\nyields the egress interface (311/312) and the bound-interface name (300).\nRuns BEFORE the ASN lookup, so self/local-subnet destinations skip it.\nNon-fatal: a per-namespace discovery failure just leaves that namespace's\nsockets unclassified (and is retried with backoff). Default false." }, "localityRefreshInterval": { "type": "string", - "description": "How often to re-discover local addresses/routes per namespace so runtime\nchanges (interfaces up/down, routes added) are picked up. Newly-appeared\nnamespaces are always snapshotted on the next reconcile regardless. 0 =\ndiscover once per namespace, never refresh." + "description": "How often to re-discover local addresses/routes per namespace so runtime\nchanges (interfaces up/down, routes added) are picked up. Newly-appeared\nnamespaces are always snapshotted on the next reconcile regardless. 0 =\ndiscover once per namespace, never refresh. Daemon default 60s." } }, + "description": "Field-number layout (renumbered into subject blocks 2026-09; the binary form\nis never persisted — it only crosses the gRPC hop between xtcp2 and\nxtcp2ctl/xtcp2client, which are built from this repo's gen/go together, and\nprotojson/prototext map by NAME — so renumbering is safe). Add new knobs in\nthe free space of the matching block; open a new block above 250 for a new\nsubject.\n 10-39 polling \u0026 netlink (dump cadence, netlinker plumbing, io_uring)\n 40-49 namespace reconcile\n 50-59 capture / debug\n 60-79 output, destination-agnostic (dest, marshal, csv, envelope)\n 80-99 kafka destination\n 100-129 s3parquet destination\n 130-149 identity \u0026 labels stamped on every record\n 150-159 network knobs for xtcp2's own listeners\n 160-169 gRPC\n 170-179 profiling\n 200-249 best-effort enrichment (container 200s, lldp 210s, nic 220s,\n nsid 230s, asn 240-244, locality 245-249)", "title": "xtcp configuration" } } diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.py b/gen/python/xtcp_config/v1/xtcp_config_pb2.py index a471224..5296d13 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.py +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.py @@ -27,7 +27,7 @@ from buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xae \n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12+\n\tmax_loops\x18( \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x32 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x33 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18< \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x46 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18P \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12.\n\x0bwrite_files\x18Z \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x64 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12(\n\x07modulus\x18n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12+\n\nmarshal_to\x18x \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18z \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18{ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\x33\n\x11kafka_compression\x18| \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18} \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_bucket\x18~ \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18\x7f \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12+\n\rs3_access_key\x18\x80\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12+\n\rs3_secret_key\x18\x81\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12O\n s3_parquet_flush_threshold_bytes\x18\x84\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12$\n\ts3_region\x18\x85\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12\x38\n\x14s3_skip_bucket_probe\x18\x86\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12,\n\rpyroscope_url\x18\x88\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\x89\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\x8a\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\x8b\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\"\n\x04\x64\x65st\x18\x82\x01 \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12\x38\n\x10\x64\x65st_write_files\x18\x87\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12#\n\x05topic\x18\x8c\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x35\n\x0fxtcp_proto_file\x18\x8f\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12\x37\n\x10kafka_schema_url\x18\x91\x01 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12`\n\x15kafka_produce_timeout\x18\x96\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12/\n\x0b\x64\x65\x62ug_level\x18\xa0\x01 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x05label\x18\xaa\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\xb4\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12(\n\x08location\x18\xb5\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12(\n\x08hostname\x18\xb6\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12\x33\n\x0e\x64\x61\x65mon_version\x18\xba\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\x39\n\x14resolve_container_id\x18\xb7\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\'\n\x08ipv4_ttl\x18\xb8\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\xb9\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xbe\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12\x62\n\x15\x65nabled_deserializers\x18\xc8\x01 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12\"\n\x08io_uring\x18\xd2\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x46\n\x18io_uring_recv_batch_size\x18\xd3\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x44\n\x17io_uring_cqe_batch_size\x18\xd4\x01 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12(\n\x0b\x63sv_columns\x18\xdc\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x33\n\x0fpoll_jitter_pct\x18\xdd\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12S\n\x11s3_flush_interval\x18\xde\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12:\n\x13s3_flush_jitter_pct\x18\xdf\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12M\n\x1ds3_flush_threshold_jitter_pct\x18\xe0\x01 \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x42\n\x16s3_upload_max_attempts\x18\xe1\x01 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Z\n\x15s3_upload_backoff_cap\x18\xe2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12X\n\x13reconcile_frequency\x18\xe3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x33\n\x15reconcile_before_poll\x18\xe4\x01 \x01(\x08R\x13reconcileBeforePoll\x12\x37\n\x17\x65nrich_container_enable\x18\xe6\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xe7\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xe8\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xe9\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xea\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xeb\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xec\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xed\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xee\x01 \x01(\x08R\x0cpopulateNsid\x12+\n\x11\x65nrich_asn_enable\x18\xef\x01 \x01(\x08R\x0f\x65nrichAsnEnable\x12)\n\x0b\x61sn_db_path\x18\xf0\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n\x14\x61sn_refresh_interval\x18\xf1\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x12\x61snRefreshInterval\x12\x35\n\x16\x65nrich_locality_enable\x18\xf2\x01 \x01(\x08R\x14\x65nrichLocalityEnable\x12V\n\x19locality_refresh_interval\x18\xf3\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x17localityRefreshInterval:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n xtcp_config/v1/xtcp_config.proto\x12\x0extcp_config.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1b\x62uf/validate/validate.proto\"\x0c\n\nGetRequest\"A\n\x0bGetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"@\n\nSetRequest\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"A\n\x0bSetResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xb4\x02\n\x17SetPollFrequencyRequest\x12S\n\x0epoll_frequency\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x1e \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$2\x00\xc8\x01\x01R\x0bpollTimeout:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_timeout < this.poll_frequency\"N\n\x18SetPollFrequencyResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x14\n\x12TriggerPollRequest\"\x15\n\x13TriggerPollResponse\"\x89\x01\n\x17TriggerPollBurstRequest\x12#\n\x05\x63ount\x18\n \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x05\x63ount\x12I\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationB\x12\xbaH\x0f\xaa\x01\t\"\x03\x08\x90\x1c\x32\x02\x08\x01\xc8\x01\x01R\x08interval\"g\n\x18TriggerPollBurstResponse\x12\x14\n\x05\x63ount\x18\n \x01(\rR\x05\x63ount\x12\x35\n\x08interval\x18\x14 \x01(\x0b\x32\x19.google.protobuf.DurationR\x08interval\"\xe3\x02\n\x12SetS3UploadRequest\x12R\n\x11s3_flush_interval\x18\n \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12N\n s3_parquet_flush_threshold_bytes\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes:\xa8\x01\xbaH\xa4\x01\x1a\xa1\x01\n\x16SetS3Upload.atLeastOne\x12=set s3_flush_interval and/or s3_parquet_flush_threshold_bytes\x1aHhas(this.s3_flush_interval) || this.s3_parquet_flush_threshold_bytes > 0\"I\n\x13SetS3UploadResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\xf4\x02\n\x17SetEnvelopeFlushRequest\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18\n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x14 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows:\xc0\x01\xbaH\xbc\x01\x1a\xb9\x01\n\x1bSetEnvelopeFlush.atLeastOne\x12Gset envelope_flush_threshold_bytes and/or envelope_flush_threshold_rows\x1aQthis.envelope_flush_threshold_bytes > 0 || this.envelope_flush_threshold_rows > 0\"N\n\x18SetEnvelopeFlushResponse\x12\x32\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1a.xtcp_config.v1.XtcpConfigR\x06\x63onfig\"\x95 \n\nXtcpConfig\x12\x46\n\x17nl_timeout_milliseconds\x18\n \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x01R\x15nlTimeoutMilliseconds\x12S\n\x0epoll_frequency\x18\x0b \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\rpollFrequency\x12O\n\x0cpoll_timeout\x18\x0c \x01(\x0b\x32\x19.google.protobuf.DurationB\x11\xbaH\x0e\xaa\x01\x08\"\x04\x08\x80\xf5$*\x00\xc8\x01\x01R\x0bpollTimeout\x12\x32\n\x0fpoll_jitter_pct\x18\r \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\rpollJitterPct\x12+\n\tmax_loops\x18\x0e \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xa0\x8d\x06(\x00\xc8\x01\x00R\x08maxLoops\x12,\n\nnetlinkers\x18\x0f \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x01R\nnetlinkers\x12H\n\x19netlinkers_done_chan_size\x18\x10 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x01\xc8\x01\x01R\x16netlinkersDoneChanSize\x12*\n\tnlmsg_seq\x18\x11 \x01(\rB\r\xbaH\n*\x05\x18\x90N(\x00\xc8\x01\x01R\x08nlmsgSeq\x12/\n\x0bpacket_size\x18\x12 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x00\xc8\x01\x00R\npacketSize\x12\x36\n\x10packet_size_mply\x18\x13 \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x00\xc8\x01\x00R\x0epacketSizeMply\x12(\n\x07modulus\x18\x14 \x01(\x04\x42\x0e\xbaH\x0b\x32\x06\x18\xc0\x84=(\x01\xc8\x01\x01R\x07modulus\x12\x61\n\x15\x65nabled_deserializers\x18\x15 \x01(\x0b\x32$.xtcp_config.v1.EnabledDeserializersB\x06\xbaH\x03\xc8\x01\x00R\x14\x65nabledDeserializers\x12!\n\x08io_uring\x18\x16 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x07ioUring\x12\x45\n\x18io_uring_recv_batch_size\x18\x17 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x14ioUringRecvBatchSize\x12\x43\n\x17io_uring_cqe_batch_size\x18\x18 \x01(\rB\r\xbaH\n*\x05\x18\x80 (\x01\xc8\x01\x00R\x13ioUringCqeBatchSize\x12W\n\x13reconcile_frequency\x18( \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12reconcileFrequency\x12\x32\n\x15reconcile_before_poll\x18) \x01(\x08R\x13reconcileBeforePoll\x12.\n\x0bwrite_files\x18\x32 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\nwriteFiles\x12/\n\x0c\x63\x61pture_path\x18\x33 \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\x0b\x63\x61pturePath\x12\x37\n\x10\x64\x65st_write_files\x18\x34 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x00R\x0e\x64\x65stWriteFiles\x12.\n\x0b\x64\x65\x62ug_level\x18\x35 \x01(\rB\r\xbaH\n*\x05\x18\xe8\x07(\x00\xc8\x01\x01R\ndebugLevel\x12!\n\x04\x64\x65st\x18< \x01(\tB\r\xbaH\nr\x05\x10\x04\x18\x80\x04\xc8\x01\x01R\x04\x64\x65st\x12+\n\nmarshal_to\x18= \x01(\tB\x0c\xbaH\tr\x04\x10\x03\x18(\xc8\x01\x01R\tmarshalTo\x12\'\n\x0b\x63sv_columns\x18> \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ncsvColumns\x12\x34\n\x0fxtcp_proto_file\x18? \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18P\xc8\x01\x00R\rxtcpProtoFile\x12K\n\x1e\x65nvelope_flush_threshold_bytes\x18@ \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1b\x65nvelopeFlushThresholdBytes\x12I\n\x1d\x65nvelope_flush_threshold_rows\x18\x41 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1a\x65nvelopeFlushThresholdRows\x12\"\n\x05topic\x18P \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18(\xc8\x01\x00R\x05topic\x12\x36\n\x10kafka_schema_url\x18Q \x01(\tB\x0c\xbaH\tr\x04\x10\x01\x18<\xc8\x01\x00R\x0ekafkaSchemaUrl\x12_\n\x15kafka_produce_timeout\x18R \x01(\x0b\x32\x19.google.protobuf.DurationB\x10\xbaH\r\xaa\x01\x07\"\x03\x08\xd8\x04\x32\x00\xc8\x01\x00R\x13kafkaProduceTimeout\x12\x33\n\x11kafka_compression\x18S \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10kafkaCompression\x12\'\n\x0bs3_endpoint\x18\x64 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\ns3Endpoint\x12#\n\ts3_region\x18\x65 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Region\x12#\n\ts3_bucket\x18\x66 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Bucket\x12#\n\ts3_prefix\x18g \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x08s3Prefix\x12*\n\rs3_access_key\x18h \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3AccessKey\x12*\n\rs3_secret_key\x18i \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0bs3SecretKey\x12\x37\n\x14s3_skip_bucket_probe\x18j \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x11s3SkipBucketProbe\x12N\n s3_parquet_flush_threshold_bytes\x18n \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1cs3ParquetFlushThresholdBytes\x12R\n\x11s3_flush_interval\x18o \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x0fs3FlushInterval\x12\x39\n\x13s3_flush_jitter_pct\x18p \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x10s3FlushJitterPct\x12L\n\x1ds3_flush_threshold_jitter_pct\x18q \x01(\rB\n\xbaH\x07*\x02\x18\x64\xc8\x01\x00R\x19s3FlushThresholdJitterPct\x12\x41\n\x16s3_upload_max_attempts\x18r \x01(\rB\x0c\xbaH\t*\x04\x18\x64(\x01\xc8\x01\x00R\x13s3UploadMaxAttempts\x12Y\n\x15s3_upload_backoff_cap\x18s \x01(\x0b\x32\x19.google.protobuf.DurationB\x0b\xbaH\x08\xaa\x01\x02\x32\x00\xc8\x01\x00R\x12s3UploadBackoffCap\x12(\n\x08hostname\x18\x82\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08hostname\x12(\n\x08location\x18\x83\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\x08location\x12!\n\x05label\x18\x84\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x05label\x12\x1d\n\x03tag\x18\x85\x01 \x01(\tB\n\xbaH\x07r\x02\x18(\xc8\x01\x00R\x03tag\x12\x33\n\x0e\x64\x61\x65mon_version\x18\x86\x01 \x01(\tB\x0b\xbaH\x08r\x03\x18\xfd\x01\xc8\x01\x00R\rdaemonVersion\x12\'\n\x08ipv4_ttl\x18\x96\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x07ipv4Ttl\x12\x32\n\x0eipv6_hop_limit\x18\x97\x01 \x01(\rB\x0b\xbaH\x08*\x03\x18\xff\x01\xc8\x01\x00R\x0cipv6HopLimit\x12,\n\tgrpc_port\x18\xa0\x01 \x01(\rB\x0e\xbaH\x0b*\x06\x18\xff\xff\x03(\x01\xc8\x01\x01R\x08grpcPort\x12,\n\rpyroscope_url\x18\xaa\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x0cpyroscopeUrl\x12\x35\n\x12pyroscope_app_name\x18\xab\x01 \x01(\tB\x06\xbaH\x03\xc8\x01\x00R\x10pyroscopeAppName\x12\x37\n\x13pyroscope_sample_hz\x18\xac\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x11pyroscopeSampleHz\x12J\n\x1dpyroscope_upload_interval_sec\x18\xad\x01 \x01(\rB\x06\xbaH\x03\xc8\x01\x00R\x1apyroscopeUploadIntervalSec\x12\x39\n\x14resolve_container_id\x18\xc8\x01 \x01(\x08\x42\x06\xbaH\x03\xc8\x01\x00R\x12resolveContainerId\x12\x37\n\x17\x65nrich_container_enable\x18\xc9\x01 \x01(\x08R\x15\x65nrichContainerEnable\x12\x37\n\x12\x64ocker_socket_path\x18\xca\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x10\x64ockerSocketPath\x12-\n\x12\x65nrich_lldp_enable\x18\xd2\x01 \x01(\x08R\x10\x65nrichLldpEnable\x12\x35\n\x11lldpd_socket_path\x18\xd3\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\x0flldpdSocketPath\x12\x36\n\x12lldpd_version_hint\x18\xd4\x01 \x01(\tB\x07\xbaH\x04r\x02\x18\x10R\x10lldpdVersionHint\x12+\n\x11\x65nrich_nic_enable\x18\xdc\x01 \x01(\x08R\x0f\x65nrichNicEnable\x12+\n\x0cuplink_count\x18\xdd\x01 \x01(\rB\x07\xbaH\x04*\x02\x18\x02R\x0buplinkCount\x12\x36\n\x11uplink_interfaces\x18\xde\x01 \x03(\tB\x08\xbaH\x05\x92\x01\x02\x10\x02R\x10uplinkInterfaces\x12$\n\rpopulate_nsid\x18\xe6\x01 \x01(\x08R\x0cpopulateNsid\x12+\n\x11\x65nrich_asn_enable\x18\xf0\x01 \x01(\x08R\x0f\x65nrichAsnEnable\x12)\n\x0b\x61sn_db_path\x18\xf1\x01 \x01(\tB\x08\xbaH\x05r\x03\x18\xff\x01R\tasnDbPath\x12L\n\x14\x61sn_refresh_interval\x18\xf2\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x12\x61snRefreshInterval\x12\x35\n\x16\x65nrich_locality_enable\x18\xf5\x01 \x01(\x08R\x14\x65nrichLocalityEnable\x12V\n\x19locality_refresh_interval\x18\xf6\x01 \x01(\x0b\x32\x19.google.protobuf.DurationR\x17localityRefreshInterval:s\xbaHp\x1an\n\x0fXtcpConfig.poll\x12\x32Poll timeout must be less than poll poll_frequency\x1a\'this.poll_frequency > this.poll_timeout\"\x9f\x01\n\x14\x45nabledDeserializers\x12K\n\x07\x65nabled\x18\x01 \x03(\x0b\x32\x31.xtcp_config.v1.EnabledDeserializers.EnabledEntryR\x07\x65nabled\x1a:\n\x0c\x45nabledEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\x08R\x05value:\x02\x38\x01\x32\x87\x07\n\rConfigService\x12]\n\x03Get\x12\x1a.xtcp_config.v1.GetRequest\x1a\x1b.xtcp_config.v1.GetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Get:\x01*\x12]\n\x03Set\x12\x1a.xtcp_config.v1.SetRequest\x1a\x1b.xtcp_config.v1.SetResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x1a\x12/ConfigService/Set:\x01*\x12\x91\x01\n\x10SetPollFrequency\x12\'.xtcp_config.v1.SetPollFrequencyRequest\x1a(.xtcp_config.v1.SetPollFrequencyResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetPollFrequency:\x01*\x12}\n\x0bTriggerPoll\x12\".xtcp_config.v1.TriggerPollRequest\x1a#.xtcp_config.v1.TriggerPollResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/TriggerPoll:\x01*\x12\x91\x01\n\x10TriggerPollBurst\x12\'.xtcp_config.v1.TriggerPollBurstRequest\x1a(.xtcp_config.v1.TriggerPollBurstResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/TriggerPollBurst:\x01*\x12}\n\x0bSetS3Upload\x12\".xtcp_config.v1.SetS3UploadRequest\x1a#.xtcp_config.v1.SetS3UploadResponse\"%\x82\xd3\xe4\x93\x02\x1f\x1a\x1a/ConfigService/SetS3Upload:\x01*\x12\x91\x01\n\x10SetEnvelopeFlush\x12\'.xtcp_config.v1.SetEnvelopeFlushRequest\x1a(.xtcp_config.v1.SetEnvelopeFlushResponse\"*\x82\xd3\xe4\x93\x02$\x1a\x1f/ConfigService/SetEnvelopeFlush:\x01*B\x90\x01\n\x12\x63om.xtcp_config.v1B\x0fXtcpConfigProtoP\x01Z\x14./gen/go/xtcp_config\xa2\x02\x03XXX\xaa\x02\rXtcpConfig.V1\xca\x02\rXtcpConfig\\V1\xe2\x02\x19XtcpConfig\\V1\\GPBMetadata\xea\x02\x0eXtcpConfig::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -63,6 +63,8 @@ _globals['_XTCPCONFIG'].fields_by_name['poll_frequency']._serialized_options = b'\272H\016\252\001\010\"\004\010\200\365$*\000\310\001\001' _globals['_XTCPCONFIG'].fields_by_name['poll_timeout']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['poll_timeout']._serialized_options = b'\272H\016\252\001\010\"\004\010\200\365$*\000\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['poll_jitter_pct']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['poll_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['max_loops']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['max_loops']._serialized_options = b'\272H\0132\006\030\240\215\006(\000\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['netlinkers']._loaded_options = None @@ -75,22 +77,50 @@ _globals['_XTCPCONFIG'].fields_by_name['packet_size']._serialized_options = b'\272H\0132\006\030\300\204=(\000\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['packet_size_mply']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['packet_size_mply']._serialized_options = b'\272H\t*\004\030d(\000\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['modulus']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['modulus']._serialized_options = b'\272H\0132\006\030\300\204=(\001\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['enabled_deserializers']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['enabled_deserializers']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['io_uring']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['io_uring']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['io_uring_recv_batch_size']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['io_uring_recv_batch_size']._serialized_options = b'\272H\n*\005\030\200 (\001\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['io_uring_cqe_batch_size']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['io_uring_cqe_batch_size']._serialized_options = b'\272H\n*\005\030\200 (\001\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['reconcile_frequency']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['reconcile_frequency']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['write_files']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['write_files']._serialized_options = b'\272H\n*\005\030\350\007(\000\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['capture_path']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['capture_path']._serialized_options = b'\272H\tr\004\020\001\030P\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['modulus']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['modulus']._serialized_options = b'\272H\0132\006\030\300\204=(\001\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['dest_write_files']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['dest_write_files']._serialized_options = b'\272H\n*\005\030\350\007(\000\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['debug_level']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['debug_level']._serialized_options = b'\272H\n*\005\030\350\007(\000\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['dest']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['dest']._serialized_options = b'\272H\nr\005\020\004\030\200\004\310\001\001' _globals['_XTCPCONFIG'].fields_by_name['marshal_to']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['marshal_to']._serialized_options = b'\272H\tr\004\020\003\030(\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['csv_columns']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['csv_columns']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['xtcp_proto_file']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['xtcp_proto_file']._serialized_options = b'\272H\tr\004\020\001\030P\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['envelope_flush_threshold_bytes']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['envelope_flush_threshold_bytes']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['envelope_flush_threshold_rows']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['envelope_flush_threshold_rows']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['topic']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['topic']._serialized_options = b'\272H\tr\004\020\001\030(\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['kafka_schema_url']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['kafka_schema_url']._serialized_options = b'\272H\tr\004\020\001\030<\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['kafka_produce_timeout']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['kafka_produce_timeout']._serialized_options = b'\272H\r\252\001\007\"\003\010\330\0042\000\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['kafka_compression']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['kafka_compression']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['s3_endpoint']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['s3_endpoint']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_region']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_region']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['s3_bucket']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['s3_bucket']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['s3_prefix']._loaded_options = None @@ -99,76 +129,46 @@ _globals['_XTCPCONFIG'].fields_by_name['s3_access_key']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['s3_secret_key']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['s3_secret_key']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_parquet_flush_threshold_bytes']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_parquet_flush_threshold_bytes']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_region']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_region']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['s3_skip_bucket_probe']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['s3_skip_bucket_probe']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_url']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_url']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_app_name']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_app_name']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_sample_hz']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_sample_hz']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_upload_interval_sec']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['pyroscope_upload_interval_sec']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['dest']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['dest']._serialized_options = b'\272H\nr\005\020\004\030\200\004\310\001\001' - _globals['_XTCPCONFIG'].fields_by_name['dest_write_files']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['dest_write_files']._serialized_options = b'\272H\n*\005\030\350\007(\000\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['topic']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['topic']._serialized_options = b'\272H\tr\004\020\001\030(\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['xtcp_proto_file']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['xtcp_proto_file']._serialized_options = b'\272H\tr\004\020\001\030P\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['kafka_schema_url']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['kafka_schema_url']._serialized_options = b'\272H\tr\004\020\001\030<\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['kafka_produce_timeout']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['kafka_produce_timeout']._serialized_options = b'\272H\r\252\001\007\"\003\010\330\0042\000\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['debug_level']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['debug_level']._serialized_options = b'\272H\n*\005\030\350\007(\000\310\001\001' + _globals['_XTCPCONFIG'].fields_by_name['s3_parquet_flush_threshold_bytes']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_parquet_flush_threshold_bytes']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_interval']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_interval']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_jitter_pct']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_threshold_jitter_pct']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_flush_threshold_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_upload_max_attempts']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_upload_max_attempts']._serialized_options = b'\272H\t*\004\030d(\001\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['s3_upload_backoff_cap']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['s3_upload_backoff_cap']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['hostname']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['hostname']._serialized_options = b'\272H\010r\003\030\375\001\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['location']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['location']._serialized_options = b'\272H\010r\003\030\375\001\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['label']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['label']._serialized_options = b'\272H\007r\002\030(\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['tag']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['tag']._serialized_options = b'\272H\007r\002\030(\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['location']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['location']._serialized_options = b'\272H\010r\003\030\375\001\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['hostname']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['hostname']._serialized_options = b'\272H\010r\003\030\375\001\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['daemon_version']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['daemon_version']._serialized_options = b'\272H\010r\003\030\375\001\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['resolve_container_id']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['resolve_container_id']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['ipv4_ttl']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['ipv4_ttl']._serialized_options = b'\272H\010*\003\030\377\001\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['ipv6_hop_limit']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['ipv6_hop_limit']._serialized_options = b'\272H\010*\003\030\377\001\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['grpc_port']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['grpc_port']._serialized_options = b'\272H\013*\006\030\377\377\003(\001\310\001\001' - _globals['_XTCPCONFIG'].fields_by_name['enabled_deserializers']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['enabled_deserializers']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['io_uring']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['io_uring']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['io_uring_recv_batch_size']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['io_uring_recv_batch_size']._serialized_options = b'\272H\n*\005\030\200 (\001\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['io_uring_cqe_batch_size']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['io_uring_cqe_batch_size']._serialized_options = b'\272H\n*\005\030\200 (\001\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['csv_columns']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['csv_columns']._serialized_options = b'\272H\003\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['poll_jitter_pct']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['poll_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_interval']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_interval']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_jitter_pct']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_threshold_jitter_pct']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_flush_threshold_jitter_pct']._serialized_options = b'\272H\007*\002\030d\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_upload_max_attempts']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_upload_max_attempts']._serialized_options = b'\272H\t*\004\030d(\001\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['s3_upload_backoff_cap']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['s3_upload_backoff_cap']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' - _globals['_XTCPCONFIG'].fields_by_name['reconcile_frequency']._loaded_options = None - _globals['_XTCPCONFIG'].fields_by_name['reconcile_frequency']._serialized_options = b'\272H\010\252\001\0022\000\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_url']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_url']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_app_name']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_app_name']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_sample_hz']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_sample_hz']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_upload_interval_sec']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['pyroscope_upload_interval_sec']._serialized_options = b'\272H\003\310\001\000' + _globals['_XTCPCONFIG'].fields_by_name['resolve_container_id']._loaded_options = None + _globals['_XTCPCONFIG'].fields_by_name['resolve_container_id']._serialized_options = b'\272H\003\310\001\000' _globals['_XTCPCONFIG'].fields_by_name['docker_socket_path']._loaded_options = None _globals['_XTCPCONFIG'].fields_by_name['docker_socket_path']._serialized_options = b'\272H\005r\003\030\377\001' _globals['_XTCPCONFIG'].fields_by_name['lldpd_socket_path']._loaded_options = None @@ -228,11 +228,11 @@ _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_start=1846 _globals['_SETENVELOPEFLUSHRESPONSE']._serialized_end=1924 _globals['_XTCPCONFIG']._serialized_start=1927 - _globals['_XTCPCONFIG']._serialized_end=6069 - _globals['_ENABLEDDESERIALIZERS']._serialized_start=6072 - _globals['_ENABLEDDESERIALIZERS']._serialized_end=6231 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=6173 - _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=6231 - _globals['_CONFIGSERVICE']._serialized_start=6234 - _globals['_CONFIGSERVICE']._serialized_end=7137 + _globals['_XTCPCONFIG']._serialized_end=6044 + _globals['_ENABLEDDESERIALIZERS']._serialized_start=6047 + _globals['_ENABLEDDESERIALIZERS']._serialized_end=6206 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_start=6148 + _globals['_ENABLEDDESERIALIZERS_ENABLEDENTRY']._serialized_end=6206 + _globals['_CONFIGSERVICE']._serialized_start=6209 + _globals['_CONFIGSERVICE']._serialized_end=7112 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi index 721aacf..651c35f 100644 --- a/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi +++ b/gen/python/xtcp_config/v1/xtcp_config_pb2.pyi @@ -100,64 +100,64 @@ class SetEnvelopeFlushResponse(_message.Message): def __init__(self, config: _Optional[_Union[XtcpConfig, _Mapping]] = ...) -> None: ... class XtcpConfig(_message.Message): - __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "write_files", "capture_path", "modulus", "marshal_to", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "kafka_compression", "s3_endpoint", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_parquet_flush_threshold_bytes", "s3_region", "s3_skip_bucket_probe", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "dest", "dest_write_files", "topic", "xtcp_proto_file", "kafka_schema_url", "kafka_produce_timeout", "debug_level", "label", "tag", "location", "hostname", "daemon_version", "resolve_container_id", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "csv_columns", "poll_jitter_pct", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "reconcile_frequency", "reconcile_before_poll", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid", "enrich_asn_enable", "asn_db_path", "asn_refresh_interval", "enrich_locality_enable", "locality_refresh_interval") + __slots__ = ("nl_timeout_milliseconds", "poll_frequency", "poll_timeout", "poll_jitter_pct", "max_loops", "netlinkers", "netlinkers_done_chan_size", "nlmsg_seq", "packet_size", "packet_size_mply", "modulus", "enabled_deserializers", "io_uring", "io_uring_recv_batch_size", "io_uring_cqe_batch_size", "reconcile_frequency", "reconcile_before_poll", "write_files", "capture_path", "dest_write_files", "debug_level", "dest", "marshal_to", "csv_columns", "xtcp_proto_file", "envelope_flush_threshold_bytes", "envelope_flush_threshold_rows", "topic", "kafka_schema_url", "kafka_produce_timeout", "kafka_compression", "s3_endpoint", "s3_region", "s3_bucket", "s3_prefix", "s3_access_key", "s3_secret_key", "s3_skip_bucket_probe", "s3_parquet_flush_threshold_bytes", "s3_flush_interval", "s3_flush_jitter_pct", "s3_flush_threshold_jitter_pct", "s3_upload_max_attempts", "s3_upload_backoff_cap", "hostname", "location", "label", "tag", "daemon_version", "ipv4_ttl", "ipv6_hop_limit", "grpc_port", "pyroscope_url", "pyroscope_app_name", "pyroscope_sample_hz", "pyroscope_upload_interval_sec", "resolve_container_id", "enrich_container_enable", "docker_socket_path", "enrich_lldp_enable", "lldpd_socket_path", "lldpd_version_hint", "enrich_nic_enable", "uplink_count", "uplink_interfaces", "populate_nsid", "enrich_asn_enable", "asn_db_path", "asn_refresh_interval", "enrich_locality_enable", "locality_refresh_interval") NL_TIMEOUT_MILLISECONDS_FIELD_NUMBER: _ClassVar[int] POLL_FREQUENCY_FIELD_NUMBER: _ClassVar[int] POLL_TIMEOUT_FIELD_NUMBER: _ClassVar[int] + POLL_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] MAX_LOOPS_FIELD_NUMBER: _ClassVar[int] NETLINKERS_FIELD_NUMBER: _ClassVar[int] NETLINKERS_DONE_CHAN_SIZE_FIELD_NUMBER: _ClassVar[int] NLMSG_SEQ_FIELD_NUMBER: _ClassVar[int] PACKET_SIZE_FIELD_NUMBER: _ClassVar[int] PACKET_SIZE_MPLY_FIELD_NUMBER: _ClassVar[int] + MODULUS_FIELD_NUMBER: _ClassVar[int] + ENABLED_DESERIALIZERS_FIELD_NUMBER: _ClassVar[int] + IO_URING_FIELD_NUMBER: _ClassVar[int] + IO_URING_RECV_BATCH_SIZE_FIELD_NUMBER: _ClassVar[int] + IO_URING_CQE_BATCH_SIZE_FIELD_NUMBER: _ClassVar[int] + RECONCILE_FREQUENCY_FIELD_NUMBER: _ClassVar[int] + RECONCILE_BEFORE_POLL_FIELD_NUMBER: _ClassVar[int] WRITE_FILES_FIELD_NUMBER: _ClassVar[int] CAPTURE_PATH_FIELD_NUMBER: _ClassVar[int] - MODULUS_FIELD_NUMBER: _ClassVar[int] + DEST_WRITE_FILES_FIELD_NUMBER: _ClassVar[int] + DEBUG_LEVEL_FIELD_NUMBER: _ClassVar[int] + DEST_FIELD_NUMBER: _ClassVar[int] MARSHAL_TO_FIELD_NUMBER: _ClassVar[int] + CSV_COLUMNS_FIELD_NUMBER: _ClassVar[int] + XTCP_PROTO_FILE_FIELD_NUMBER: _ClassVar[int] ENVELOPE_FLUSH_THRESHOLD_BYTES_FIELD_NUMBER: _ClassVar[int] ENVELOPE_FLUSH_THRESHOLD_ROWS_FIELD_NUMBER: _ClassVar[int] + TOPIC_FIELD_NUMBER: _ClassVar[int] + KAFKA_SCHEMA_URL_FIELD_NUMBER: _ClassVar[int] + KAFKA_PRODUCE_TIMEOUT_FIELD_NUMBER: _ClassVar[int] KAFKA_COMPRESSION_FIELD_NUMBER: _ClassVar[int] S3_ENDPOINT_FIELD_NUMBER: _ClassVar[int] + S3_REGION_FIELD_NUMBER: _ClassVar[int] S3_BUCKET_FIELD_NUMBER: _ClassVar[int] S3_PREFIX_FIELD_NUMBER: _ClassVar[int] S3_ACCESS_KEY_FIELD_NUMBER: _ClassVar[int] S3_SECRET_KEY_FIELD_NUMBER: _ClassVar[int] - S3_PARQUET_FLUSH_THRESHOLD_BYTES_FIELD_NUMBER: _ClassVar[int] - S3_REGION_FIELD_NUMBER: _ClassVar[int] S3_SKIP_BUCKET_PROBE_FIELD_NUMBER: _ClassVar[int] - PYROSCOPE_URL_FIELD_NUMBER: _ClassVar[int] - PYROSCOPE_APP_NAME_FIELD_NUMBER: _ClassVar[int] - PYROSCOPE_SAMPLE_HZ_FIELD_NUMBER: _ClassVar[int] - PYROSCOPE_UPLOAD_INTERVAL_SEC_FIELD_NUMBER: _ClassVar[int] - DEST_FIELD_NUMBER: _ClassVar[int] - DEST_WRITE_FILES_FIELD_NUMBER: _ClassVar[int] - TOPIC_FIELD_NUMBER: _ClassVar[int] - XTCP_PROTO_FILE_FIELD_NUMBER: _ClassVar[int] - KAFKA_SCHEMA_URL_FIELD_NUMBER: _ClassVar[int] - KAFKA_PRODUCE_TIMEOUT_FIELD_NUMBER: _ClassVar[int] - DEBUG_LEVEL_FIELD_NUMBER: _ClassVar[int] + S3_PARQUET_FLUSH_THRESHOLD_BYTES_FIELD_NUMBER: _ClassVar[int] + S3_FLUSH_INTERVAL_FIELD_NUMBER: _ClassVar[int] + S3_FLUSH_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] + S3_FLUSH_THRESHOLD_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] + S3_UPLOAD_MAX_ATTEMPTS_FIELD_NUMBER: _ClassVar[int] + S3_UPLOAD_BACKOFF_CAP_FIELD_NUMBER: _ClassVar[int] + HOSTNAME_FIELD_NUMBER: _ClassVar[int] + LOCATION_FIELD_NUMBER: _ClassVar[int] LABEL_FIELD_NUMBER: _ClassVar[int] TAG_FIELD_NUMBER: _ClassVar[int] - LOCATION_FIELD_NUMBER: _ClassVar[int] - HOSTNAME_FIELD_NUMBER: _ClassVar[int] DAEMON_VERSION_FIELD_NUMBER: _ClassVar[int] - RESOLVE_CONTAINER_ID_FIELD_NUMBER: _ClassVar[int] IPV4_TTL_FIELD_NUMBER: _ClassVar[int] IPV6_HOP_LIMIT_FIELD_NUMBER: _ClassVar[int] GRPC_PORT_FIELD_NUMBER: _ClassVar[int] - ENABLED_DESERIALIZERS_FIELD_NUMBER: _ClassVar[int] - IO_URING_FIELD_NUMBER: _ClassVar[int] - IO_URING_RECV_BATCH_SIZE_FIELD_NUMBER: _ClassVar[int] - IO_URING_CQE_BATCH_SIZE_FIELD_NUMBER: _ClassVar[int] - CSV_COLUMNS_FIELD_NUMBER: _ClassVar[int] - POLL_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] - S3_FLUSH_INTERVAL_FIELD_NUMBER: _ClassVar[int] - S3_FLUSH_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] - S3_FLUSH_THRESHOLD_JITTER_PCT_FIELD_NUMBER: _ClassVar[int] - S3_UPLOAD_MAX_ATTEMPTS_FIELD_NUMBER: _ClassVar[int] - S3_UPLOAD_BACKOFF_CAP_FIELD_NUMBER: _ClassVar[int] - RECONCILE_FREQUENCY_FIELD_NUMBER: _ClassVar[int] - RECONCILE_BEFORE_POLL_FIELD_NUMBER: _ClassVar[int] + PYROSCOPE_URL_FIELD_NUMBER: _ClassVar[int] + PYROSCOPE_APP_NAME_FIELD_NUMBER: _ClassVar[int] + PYROSCOPE_SAMPLE_HZ_FIELD_NUMBER: _ClassVar[int] + PYROSCOPE_UPLOAD_INTERVAL_SEC_FIELD_NUMBER: _ClassVar[int] + RESOLVE_CONTAINER_ID_FIELD_NUMBER: _ClassVar[int] ENRICH_CONTAINER_ENABLE_FIELD_NUMBER: _ClassVar[int] DOCKER_SOCKET_PATH_FIELD_NUMBER: _ClassVar[int] ENRICH_LLDP_ENABLE_FIELD_NUMBER: _ClassVar[int] @@ -175,60 +175,60 @@ class XtcpConfig(_message.Message): nl_timeout_milliseconds: int poll_frequency: _duration_pb2.Duration poll_timeout: _duration_pb2.Duration + poll_jitter_pct: int max_loops: int netlinkers: int netlinkers_done_chan_size: int nlmsg_seq: int packet_size: int packet_size_mply: int + modulus: int + enabled_deserializers: EnabledDeserializers + io_uring: bool + io_uring_recv_batch_size: int + io_uring_cqe_batch_size: int + reconcile_frequency: _duration_pb2.Duration + reconcile_before_poll: bool write_files: int capture_path: str - modulus: int + dest_write_files: int + debug_level: int + dest: str marshal_to: str + csv_columns: str + xtcp_proto_file: str envelope_flush_threshold_bytes: int envelope_flush_threshold_rows: int + topic: str + kafka_schema_url: str + kafka_produce_timeout: _duration_pb2.Duration kafka_compression: str s3_endpoint: str + s3_region: str s3_bucket: str s3_prefix: str s3_access_key: str s3_secret_key: str - s3_parquet_flush_threshold_bytes: int - s3_region: str s3_skip_bucket_probe: bool - pyroscope_url: str - pyroscope_app_name: str - pyroscope_sample_hz: int - pyroscope_upload_interval_sec: int - dest: str - dest_write_files: int - topic: str - xtcp_proto_file: str - kafka_schema_url: str - kafka_produce_timeout: _duration_pb2.Duration - debug_level: int + s3_parquet_flush_threshold_bytes: int + s3_flush_interval: _duration_pb2.Duration + s3_flush_jitter_pct: int + s3_flush_threshold_jitter_pct: int + s3_upload_max_attempts: int + s3_upload_backoff_cap: _duration_pb2.Duration + hostname: str + location: str label: str tag: str - location: str - hostname: str daemon_version: str - resolve_container_id: bool ipv4_ttl: int ipv6_hop_limit: int grpc_port: int - enabled_deserializers: EnabledDeserializers - io_uring: bool - io_uring_recv_batch_size: int - io_uring_cqe_batch_size: int - csv_columns: str - poll_jitter_pct: int - s3_flush_interval: _duration_pb2.Duration - s3_flush_jitter_pct: int - s3_flush_threshold_jitter_pct: int - s3_upload_max_attempts: int - s3_upload_backoff_cap: _duration_pb2.Duration - reconcile_frequency: _duration_pb2.Duration - reconcile_before_poll: bool + pyroscope_url: str + pyroscope_app_name: str + pyroscope_sample_hz: int + pyroscope_upload_interval_sec: int + resolve_container_id: bool enrich_container_enable: bool docker_socket_path: str enrich_lldp_enable: bool @@ -243,7 +243,7 @@ class XtcpConfig(_message.Message): asn_refresh_interval: _duration_pb2.Duration enrich_locality_enable: bool locality_refresh_interval: _duration_pb2.Duration - def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., modulus: _Optional[int] = ..., marshal_to: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_region: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., dest: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., topic: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., debug_level: _Optional[int] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., location: _Optional[str] = ..., hostname: _Optional[str] = ..., daemon_version: _Optional[str] = ..., resolve_container_id: _Optional[bool] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., csv_columns: _Optional[str] = ..., poll_jitter_pct: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ..., enrich_asn_enable: _Optional[bool] = ..., asn_db_path: _Optional[str] = ..., asn_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., enrich_locality_enable: _Optional[bool] = ..., locality_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ... + def __init__(self, nl_timeout_milliseconds: _Optional[int] = ..., poll_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., poll_jitter_pct: _Optional[int] = ..., max_loops: _Optional[int] = ..., netlinkers: _Optional[int] = ..., netlinkers_done_chan_size: _Optional[int] = ..., nlmsg_seq: _Optional[int] = ..., packet_size: _Optional[int] = ..., packet_size_mply: _Optional[int] = ..., modulus: _Optional[int] = ..., enabled_deserializers: _Optional[_Union[EnabledDeserializers, _Mapping]] = ..., io_uring: _Optional[bool] = ..., io_uring_recv_batch_size: _Optional[int] = ..., io_uring_cqe_batch_size: _Optional[int] = ..., reconcile_frequency: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., reconcile_before_poll: _Optional[bool] = ..., write_files: _Optional[int] = ..., capture_path: _Optional[str] = ..., dest_write_files: _Optional[int] = ..., debug_level: _Optional[int] = ..., dest: _Optional[str] = ..., marshal_to: _Optional[str] = ..., csv_columns: _Optional[str] = ..., xtcp_proto_file: _Optional[str] = ..., envelope_flush_threshold_bytes: _Optional[int] = ..., envelope_flush_threshold_rows: _Optional[int] = ..., topic: _Optional[str] = ..., kafka_schema_url: _Optional[str] = ..., kafka_produce_timeout: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., kafka_compression: _Optional[str] = ..., s3_endpoint: _Optional[str] = ..., s3_region: _Optional[str] = ..., s3_bucket: _Optional[str] = ..., s3_prefix: _Optional[str] = ..., s3_access_key: _Optional[str] = ..., s3_secret_key: _Optional[str] = ..., s3_skip_bucket_probe: _Optional[bool] = ..., s3_parquet_flush_threshold_bytes: _Optional[int] = ..., s3_flush_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., s3_flush_jitter_pct: _Optional[int] = ..., s3_flush_threshold_jitter_pct: _Optional[int] = ..., s3_upload_max_attempts: _Optional[int] = ..., s3_upload_backoff_cap: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., daemon_version: _Optional[str] = ..., ipv4_ttl: _Optional[int] = ..., ipv6_hop_limit: _Optional[int] = ..., grpc_port: _Optional[int] = ..., pyroscope_url: _Optional[str] = ..., pyroscope_app_name: _Optional[str] = ..., pyroscope_sample_hz: _Optional[int] = ..., pyroscope_upload_interval_sec: _Optional[int] = ..., resolve_container_id: _Optional[bool] = ..., enrich_container_enable: _Optional[bool] = ..., docker_socket_path: _Optional[str] = ..., enrich_lldp_enable: _Optional[bool] = ..., lldpd_socket_path: _Optional[str] = ..., lldpd_version_hint: _Optional[str] = ..., enrich_nic_enable: _Optional[bool] = ..., uplink_count: _Optional[int] = ..., uplink_interfaces: _Optional[_Iterable[str]] = ..., populate_nsid: _Optional[bool] = ..., enrich_asn_enable: _Optional[bool] = ..., asn_db_path: _Optional[str] = ..., asn_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ..., enrich_locality_enable: _Optional[bool] = ..., locality_refresh_interval: _Optional[_Union[datetime.timedelta, _duration_pb2.Duration, _Mapping]] = ...) -> None: ... class EnabledDeserializers(_message.Message): __slots__ = ("enabled",) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py index ea798c8..7c61740 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc6>\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12@\n\x1dinet_diag_msg_socket_dest_asn\x18\xf3\x07 \x01(\x04R\x18inetDiagMsgSocketDestAsn\x12G\n!inet_diag_msg_socket_next_hop_asn\x18\xf4\x07 \x01(\x04R\x1binetDiagMsgSocketNextHopAsn\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12S\n\'inet_diag_msg_socket_dest_network_owner\x18\xfa\x07 \x01(\tR!inetDiagMsgSocketDestNetworkOwner\x12x\n\"inet_diag_msg_socket_dest_locality\x18\xfb\x07 \x01(\x0e\x32,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x1dinetDiagMsgSocketDestLocality\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_send_scale\x18\xb7\t \x01(\rR\x10tcpInfoSendScale\x12,\n\x12tcp_info_rcv_scale\x18\xb8\t \x01(\rR\x0ftcpInfoRcvScale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x46\n tcp_info_fast_open_client_failed\x18\xba\t \x01(\rR\x1btcpInfoFastOpenClientFailed\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12(\n\x10tcp_info_rtt_var\x18\xcf\t \x01(\rR\rtcpInfoRttVar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12(\n\x10tcp_info_adv_mss\x18\xd2\t \x01(\rR\rtcpInfoAdvMss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x35\n\x17tcp_info_not_sent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotSentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12?\n\x1b\x63ongestion_algorithm_string\x18\x94\n \x01(\tR\x19\x63ongestionAlgorithmString\x12t\n\x19\x63ongestion_algorithm_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x17\x63ongestionAlgorithmEnum\x12\'\n\x0ftype_of_service\x18\xf9\n \x01(\rR\rtypeOfService\x12$\n\rtraffic_class\x18\xfa\n \x01(\rR\x0ctrafficClass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12-\n\x13sk_mem_info_rcv_buf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvBuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12-\n\x13sk_mem_info_snd_buf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndBuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12&\n\x0eshutdown_state\x18\xc0\x0c \x01(\rR\rshutdownState\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12,\n\x12vegas_info_rtt_cnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttCnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12,\n\x12vegas_info_min_rtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinRtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12\x1a\n\x08\x63lass_id\x18\xd1\x0f \x01(\rR\x07\x63lassId\x12\x1a\n\x08sock_opt\x18\xd2\x0f \x01(\rR\x07sockOpt\x12\x18\n\x07\x63_group\x18\xb7\x10 \x01(\x04R\x06\x63Group\"g\n\x08Locality\x12\x18\n\x14LOCALITY_UNSPECIFIED\x10\x00\x12\x11\n\rLOCALITY_SELF\x10\x01\x12\x19\n\x15LOCALITY_LOCAL_SUBNET\x10\x02\x12\x13\n\x0fLOCALITY_REMOTE\x10\x03\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n*xtcp_flat_record/v1/xtcp_flat_record.proto\x12\x13xtcp_flat_record.v1\"A\n\x08\x45nvelope\x12\x35\n\x03row\x18\n \x03(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x03row\"\xc7\x44\n\x0eXtcpFlatRecord\x12%\n\x0eschema_version\x18\x01 \x01(\rR\rschemaVersion\x12%\n\x0e\x64\x61\x65mon_version\x18\x02 \x01(\tR\rdaemonVersion\x12!\n\x0ctimestamp_ns\x18\n \x01(\x03R\x0btimestampNs\x12\x1a\n\x08hostname\x18\x14 \x01(\tR\x08hostname\x12\x1a\n\x08location\x18\x15 \x01(\tR\x08location\x12\x14\n\x05netns\x18\x1e \x01(\tR\x05netns\x12\x1f\n\x0bnetns_inode\x18\x1f \x01(\x04R\nnetnsInode\x12\x12\n\x04nsid\x18 \x01(\rR\x04nsid\x12!\n\x0c\x63ontainer_id\x18( \x01(\tR\x0b\x63ontainerId\x12+\n\x11\x63ontainer_runtime\x18) \x01(\tR\x10\x63ontainerRuntime\x12%\n\x0e\x63ontainer_name\x18* \x01(\tR\rcontainerName\x12\'\n\x0f\x63ontainer_image\x18+ \x01(\tR\x0e\x63ontainerImage\x12\x14\n\x05label\x18\x32 \x01(\tR\x05label\x12\x10\n\x03tag\x18\x33 \x01(\tR\x03tag\x12%\n\x0erecord_counter\x18< \x01(\x04R\rrecordCounter\x12\x1b\n\tsocket_fd\x18= \x01(\x04R\x08socketFd\x12!\n\x0cnetlinker_id\x18> \x01(\x04R\x0bnetlinkerId\x12%\n\x0euplink1_ifname\x18\x64 \x01(\tR\ruplink1Ifname\x12,\n\x12uplink1_nic_driver\x18\x65 \x01(\tR\x10uplink1NicDriver\x12*\n\x11uplink1_nic_model\x18\x66 \x01(\tR\x0fuplink1NicModel\x12\x33\n\x16uplink1_nic_pci_vendor\x18g \x01(\rR\x13uplink1NicPciVendor\x12\x33\n\x16uplink1_nic_pci_device\x18h \x01(\rR\x13uplink1NicPciDevice\x12/\n\x14uplink1_nic_bus_info\x18i \x01(\tR\x11uplink1NicBusInfo\x12\x33\n\x16uplink1_nic_speed_mbps\x18j \x01(\rR\x13uplink1NicSpeedMbps\x12\x33\n\x16uplink1_nic_fw_version\x18k \x01(\tR\x13uplink1NicFwVersion\x12\x39\n\x19uplink1_lldp_chassis_name\x18x \x01(\tR\x16uplink1LldpChassisName\x12\x35\n\x17uplink1_lldp_chassis_id\x18y \x01(\tR\x14uplink1LldpChassisId\x12/\n\x14uplink1_lldp_mgmt_ip\x18z \x01(\tR\x11uplink1LldpMgmtIp\x12/\n\x14uplink1_lldp_port_id\x18{ \x01(\tR\x11uplink1LldpPortId\x12\x35\n\x17uplink1_lldp_port_descr\x18| \x01(\tR\x14uplink1LldpPortDescr\x12&\n\x0euplink2_ifname\x18\xc8\x01 \x01(\tR\ruplink2Ifname\x12-\n\x12uplink2_nic_driver\x18\xc9\x01 \x01(\tR\x10uplink2NicDriver\x12+\n\x11uplink2_nic_model\x18\xca\x01 \x01(\tR\x0fuplink2NicModel\x12\x34\n\x16uplink2_nic_pci_vendor\x18\xcb\x01 \x01(\rR\x13uplink2NicPciVendor\x12\x34\n\x16uplink2_nic_pci_device\x18\xcc\x01 \x01(\rR\x13uplink2NicPciDevice\x12\x30\n\x14uplink2_nic_bus_info\x18\xcd\x01 \x01(\tR\x11uplink2NicBusInfo\x12\x34\n\x16uplink2_nic_speed_mbps\x18\xce\x01 \x01(\rR\x13uplink2NicSpeedMbps\x12\x34\n\x16uplink2_nic_fw_version\x18\xcf\x01 \x01(\tR\x13uplink2NicFwVersion\x12:\n\x19uplink2_lldp_chassis_name\x18\xdc\x01 \x01(\tR\x16uplink2LldpChassisName\x12\x36\n\x17uplink2_lldp_chassis_id\x18\xdd\x01 \x01(\tR\x14uplink2LldpChassisId\x12\x30\n\x14uplink2_lldp_mgmt_ip\x18\xde\x01 \x01(\tR\x11uplink2LldpMgmtIp\x12\x30\n\x14uplink2_lldp_port_id\x18\xdf\x01 \x01(\tR\x11uplink2LldpPortId\x12\x36\n\x17uplink2_lldp_port_descr\x18\xe0\x01 \x01(\tR\x14uplink2LldpPortDescr\x12@\n\x1c\x65nrich_socket_interface_name\x18\xac\x02 \x01(\tR\x19\x65nrichSocketInterfaceName\x12l\n\x1b\x65nrich_socket_dest_locality\x18\xb6\x02 \x01(\x0e\x32,.xtcp_flat_record.v1.XtcpFlatRecord.LocalityR\x18\x65nrichSocketDestLocality\x12I\n!enrich_socket_dest_egress_ifindex\x18\xb7\x02 \x01(\rR\x1d\x65nrichSocketDestEgressIfindex\x12G\n enrich_socket_dest_egress_ifname\x18\xb8\x02 \x01(\tR\x1c\x65nrichSocketDestEgressIfname\x12\x34\n\x16\x65nrich_socket_dest_asn\x18\xc0\x02 \x01(\x04R\x13\x65nrichSocketDestAsn\x12\x44\n\x1f\x65nrich_socket_dest_next_hop_asn\x18\xc1\x02 \x01(\x04R\x1a\x65nrichSocketDestNextHopAsn\x12G\n enrich_socket_dest_network_owner\x18\xc2\x02 \x01(\tR\x1c\x65nrichSocketDestNetworkOwner\x12\x30\n\x14inet_diag_msg_family\x18\xe9\x07 \x01(\rR\x11inetDiagMsgFamily\x12.\n\x13inet_diag_msg_state\x18\xea\x07 \x01(\rR\x10inetDiagMsgState\x12.\n\x13inet_diag_msg_timer\x18\xeb\x07 \x01(\rR\x10inetDiagMsgTimer\x12\x32\n\x15inet_diag_msg_retrans\x18\xec\x07 \x01(\rR\x12inetDiagMsgRetrans\x12\x46\n inet_diag_msg_socket_source_port\x18\xed\x07 \x01(\rR\x1binetDiagMsgSocketSourcePort\x12P\n%inet_diag_msg_socket_destination_port\x18\xee\x07 \x01(\rR inetDiagMsgSocketDestinationPort\x12=\n\x1binet_diag_msg_socket_source\x18\xef\x07 \x01(\x0cR\x17inetDiagMsgSocketSource\x12G\n inet_diag_msg_socket_destination\x18\xf0\x07 \x01(\x0cR\x1cinetDiagMsgSocketDestination\x12\x43\n\x1einet_diag_msg_socket_interface\x18\xf1\x07 \x01(\rR\x1ainetDiagMsgSocketInterface\x12=\n\x1binet_diag_msg_socket_cookie\x18\xf2\x07 \x01(\x04R\x17inetDiagMsgSocketCookie\x12\x32\n\x15inet_diag_msg_expires\x18\xf5\x07 \x01(\rR\x12inetDiagMsgExpires\x12\x30\n\x14inet_diag_msg_rqueue\x18\xf6\x07 \x01(\rR\x11inetDiagMsgRqueue\x12\x30\n\x14inet_diag_msg_wqueue\x18\xf7\x07 \x01(\rR\x11inetDiagMsgWqueue\x12*\n\x11inet_diag_msg_uid\x18\xf8\x07 \x01(\rR\x0einetDiagMsgUid\x12.\n\x13inet_diag_msg_inode\x18\xf9\x07 \x01(\rR\x10inetDiagMsgInode\x12#\n\rmem_info_rmem\x18\xcd\x08 \x01(\rR\x0bmemInfoRmem\x12#\n\rmem_info_wmem\x18\xce\x08 \x01(\rR\x0bmemInfoWmem\x12#\n\rmem_info_fmem\x18\xcf\x08 \x01(\rR\x0bmemInfoFmem\x12#\n\rmem_info_tmem\x18\xd0\x08 \x01(\rR\x0bmemInfoTmem\x12%\n\x0etcp_info_state\x18\xb1\t \x01(\rR\x0ctcpInfoState\x12*\n\x11tcp_info_ca_state\x18\xb2\t \x01(\rR\x0etcpInfoCaState\x12\x31\n\x14tcp_info_retransmits\x18\xb3\t \x01(\rR\x12tcpInfoRetransmits\x12\'\n\x0ftcp_info_probes\x18\xb4\t \x01(\rR\rtcpInfoProbes\x12)\n\x10tcp_info_backoff\x18\xb5\t \x01(\rR\x0etcpInfoBackoff\x12)\n\x10tcp_info_options\x18\xb6\t \x01(\rR\x0etcpInfoOptions\x12.\n\x13tcp_info_snd_wscale\x18\xb7\t \x01(\rR\x10tcpInfoSndWscale\x12.\n\x13tcp_info_rcv_wscale\x18\xb8\t \x01(\rR\x10tcpInfoRcvWscale\x12J\n\"tcp_info_delivery_rate_app_limited\x18\xb9\t \x01(\rR\x1dtcpInfoDeliveryRateAppLimited\x12\x41\n\x1dtcp_info_fastopen_client_fail\x18\xba\t \x01(\rR\x19tcpInfoFastopenClientFail\x12!\n\x0ctcp_info_rto\x18\xbf\t \x01(\rR\ntcpInfoRto\x12!\n\x0ctcp_info_ato\x18\xc0\t \x01(\rR\ntcpInfoAto\x12(\n\x10tcp_info_snd_mss\x18\xc1\t \x01(\rR\rtcpInfoSndMss\x12(\n\x10tcp_info_rcv_mss\x18\xc2\t \x01(\rR\rtcpInfoRcvMss\x12)\n\x10tcp_info_unacked\x18\xc3\t \x01(\rR\x0etcpInfoUnacked\x12\'\n\x0ftcp_info_sacked\x18\xc4\t \x01(\rR\rtcpInfoSacked\x12#\n\rtcp_info_lost\x18\xc5\t \x01(\rR\x0btcpInfoLost\x12)\n\x10tcp_info_retrans\x18\xc6\t \x01(\rR\x0etcpInfoRetrans\x12)\n\x10tcp_info_fackets\x18\xc7\t \x01(\rR\x0etcpInfoFackets\x12\x35\n\x17tcp_info_last_data_sent\x18\xc8\t \x01(\rR\x13tcpInfoLastDataSent\x12\x33\n\x16tcp_info_last_ack_sent\x18\xc9\t \x01(\rR\x12tcpInfoLastAckSent\x12\x35\n\x17tcp_info_last_data_recv\x18\xca\t \x01(\rR\x13tcpInfoLastDataRecv\x12\x33\n\x16tcp_info_last_ack_recv\x18\xcb\t \x01(\rR\x12tcpInfoLastAckRecv\x12#\n\rtcp_info_pmtu\x18\xcc\t \x01(\rR\x0btcpInfoPmtu\x12\x32\n\x15tcp_info_rcv_ssthresh\x18\xcd\t \x01(\rR\x12tcpInfoRcvSsthresh\x12!\n\x0ctcp_info_rtt\x18\xce\t \x01(\rR\ntcpInfoRtt\x12\'\n\x0ftcp_info_rttvar\x18\xcf\t \x01(\rR\rtcpInfoRttvar\x12\x32\n\x15tcp_info_snd_ssthresh\x18\xd0\t \x01(\rR\x12tcpInfoSndSsthresh\x12*\n\x11tcp_info_snd_cwnd\x18\xd1\t \x01(\rR\x0etcpInfoSndCwnd\x12\'\n\x0ftcp_info_advmss\x18\xd2\t \x01(\rR\rtcpInfoAdvmss\x12/\n\x13tcp_info_reordering\x18\xd3\t \x01(\rR\x11tcpInfoReordering\x12(\n\x10tcp_info_rcv_rtt\x18\xd4\t \x01(\rR\rtcpInfoRcvRtt\x12,\n\x12tcp_info_rcv_space\x18\xd5\t \x01(\rR\x0ftcpInfoRcvSpace\x12\x34\n\x16tcp_info_total_retrans\x18\xd6\t \x01(\rR\x13tcpInfoTotalRetrans\x12\x30\n\x14tcp_info_pacing_rate\x18\xd7\t \x01(\x04R\x11tcpInfoPacingRate\x12\x37\n\x18tcp_info_max_pacing_rate\x18\xd8\t \x01(\x04R\x14tcpInfoMaxPacingRate\x12\x30\n\x14tcp_info_bytes_acked\x18\xd9\t \x01(\x04R\x11tcpInfoBytesAcked\x12\x36\n\x17tcp_info_bytes_received\x18\xda\t \x01(\x04R\x14tcpInfoBytesReceived\x12*\n\x11tcp_info_segs_out\x18\xdb\t \x01(\rR\x0etcpInfoSegsOut\x12(\n\x10tcp_info_segs_in\x18\xdc\t \x01(\rR\rtcpInfoSegsIn\x12\x34\n\x16tcp_info_notsent_bytes\x18\xdd\t \x01(\rR\x13tcpInfoNotsentBytes\x12(\n\x10tcp_info_min_rtt\x18\xde\t \x01(\rR\rtcpInfoMinRtt\x12\x31\n\x15tcp_info_data_segs_in\x18\xdf\t \x01(\rR\x11tcpInfoDataSegsIn\x12\x33\n\x16tcp_info_data_segs_out\x18\xe0\t \x01(\rR\x12tcpInfoDataSegsOut\x12\x34\n\x16tcp_info_delivery_rate\x18\xe1\t \x01(\x04R\x13tcpInfoDeliveryRate\x12,\n\x12tcp_info_busy_time\x18\xe2\t \x01(\x04R\x0ftcpInfoBusyTime\x12\x32\n\x15tcp_info_rwnd_limited\x18\xe3\t \x01(\x04R\x12tcpInfoRwndLimited\x12\x36\n\x17tcp_info_sndbuf_limited\x18\xe4\t \x01(\x04R\x14tcpInfoSndbufLimited\x12-\n\x12tcp_info_delivered\x18\xe5\t \x01(\rR\x10tcpInfoDelivered\x12\x32\n\x15tcp_info_delivered_ce\x18\xe6\t \x01(\rR\x12tcpInfoDeliveredCe\x12.\n\x13tcp_info_bytes_sent\x18\xe7\t \x01(\x04R\x10tcpInfoBytesSent\x12\x34\n\x16tcp_info_bytes_retrans\x18\xe8\t \x01(\x04R\x13tcpInfoBytesRetrans\x12.\n\x13tcp_info_dsack_dups\x18\xe9\t \x01(\rR\x10tcpInfoDsackDups\x12.\n\x13tcp_info_reord_seen\x18\xea\t \x01(\rR\x10tcpInfoReordSeen\x12\x30\n\x14tcp_info_rcv_ooopack\x18\xeb\t \x01(\rR\x11tcpInfoRcvOoopack\x12(\n\x10tcp_info_snd_wnd\x18\xec\t \x01(\rR\rtcpInfoSndWnd\x12(\n\x10tcp_info_rcv_wnd\x18\xed\t \x01(\rR\rtcpInfoRcvWnd\x12\'\n\x0ftcp_info_rehash\x18\xee\t \x01(\rR\rtcpInfoRehash\x12,\n\x12tcp_info_total_rto\x18\xef\t \x01(\rR\x0ftcpInfoTotalRto\x12\x41\n\x1dtcp_info_total_rto_recoveries\x18\xf0\t \x01(\rR\x19tcpInfoTotalRtoRecoveries\x12\x35\n\x17tcp_info_total_rto_time\x18\xf1\t \x01(\rR\x13tcpInfoTotalRtoTime\x12%\n\x0einet_diag_cong\x18\x94\n \x01(\tR\x0cinetDiagCong\x12g\n\x13inet_diag_cong_enum\x18\x95\n \x01(\x0e\x32\x37.xtcp_flat_record.v1.XtcpFlatRecord.CongestionAlgorithmR\x10inetDiagCongEnum\x12#\n\rinet_diag_tos\x18\xf9\n \x01(\rR\x0binetDiagTos\x12)\n\x10inet_diag_tclass\x18\xfa\n \x01(\rR\x0einetDiagTclass\x12\x33\n\x16sk_mem_info_rmem_alloc\x18\xdd\x0b \x01(\rR\x12skMemInfoRmemAlloc\x12,\n\x12sk_mem_info_rcvbuf\x18\xde\x0b \x01(\rR\x0fskMemInfoRcvbuf\x12\x33\n\x16sk_mem_info_wmem_alloc\x18\xdf\x0b \x01(\rR\x12skMemInfoWmemAlloc\x12,\n\x12sk_mem_info_sndbuf\x18\xe0\x0b \x01(\rR\x0fskMemInfoSndbuf\x12\x31\n\x15sk_mem_info_fwd_alloc\x18\xe1\x0b \x01(\rR\x11skMemInfoFwdAlloc\x12\x35\n\x17sk_mem_info_wmem_queued\x18\xe2\x0b \x01(\rR\x13skMemInfoWmemQueued\x12,\n\x12sk_mem_info_optmem\x18\xe3\x0b \x01(\rR\x0fskMemInfoOptmem\x12.\n\x13sk_mem_info_backlog\x18\xe4\x0b \x01(\rR\x10skMemInfoBacklog\x12*\n\x11sk_mem_info_drops\x18\xe5\x0b \x01(\rR\x0eskMemInfoDrops\x12-\n\x12inet_diag_shutdown\x18\xc0\x0c \x01(\rR\x10inetDiagShutdown\x12-\n\x12vegas_info_enabled\x18\xa5\r \x01(\rR\x10vegasInfoEnabled\x12+\n\x11vegas_info_rttcnt\x18\xa6\r \x01(\rR\x0fvegasInfoRttcnt\x12%\n\x0evegas_info_rtt\x18\xa7\r \x01(\rR\x0cvegasInfoRtt\x12+\n\x11vegas_info_minrtt\x18\xa8\r \x01(\rR\x0fvegasInfoMinrtt\x12-\n\x12\x64\x63tcp_info_enabled\x18\x89\x0e \x01(\rR\x10\x64\x63tcpInfoEnabled\x12.\n\x13\x64\x63tcp_info_ce_state\x18\x8a\x0e \x01(\rR\x10\x64\x63tcpInfoCeState\x12)\n\x10\x64\x63tcp_info_alpha\x18\x8b\x0e \x01(\rR\x0e\x64\x63tcpInfoAlpha\x12*\n\x11\x64\x63tcp_info_ab_ecn\x18\x8c\x0e \x01(\rR\x0e\x64\x63tcpInfoAbEcn\x12*\n\x11\x64\x63tcp_info_ab_tot\x18\x8d\x0e \x01(\rR\x0e\x64\x63tcpInfoAbTot\x12$\n\x0e\x62\x62r_info_bw_lo\x18\xed\x0e \x01(\rR\x0b\x62\x62rInfoBwLo\x12$\n\x0e\x62\x62r_info_bw_hi\x18\xee\x0e \x01(\rR\x0b\x62\x62rInfoBwHi\x12(\n\x10\x62\x62r_info_min_rtt\x18\xef\x0e \x01(\rR\rbbrInfoMinRtt\x12\x30\n\x14\x62\x62r_info_pacing_gain\x18\xf0\x0e \x01(\rR\x11\x62\x62rInfoPacingGain\x12,\n\x12\x62\x62r_info_cwnd_gain\x18\xf1\x0e \x01(\rR\x0f\x62\x62rInfoCwndGain\x12,\n\x12inet_diag_class_id\x18\xd1\x0f \x01(\rR\x0finetDiagClassId\x12+\n\x11inet_diag_sockopt\x18\xd2\x0f \x01(\rR\x0finetDiagSockopt\x12.\n\x13inet_diag_cgroup_id\x18\xd3\x0f \x01(\x04R\x10inetDiagCgroupId\"g\n\x08Locality\x12\x18\n\x14LOCALITY_UNSPECIFIED\x10\x00\x12\x11\n\rLOCALITY_SELF\x10\x01\x12\x19\n\x15LOCALITY_LOCAL_SUBNET\x10\x02\x12\x13\n\x0fLOCALITY_REMOTE\x10\x03\"\x99\x02\n\x13\x43ongestionAlgorithm\x12$\n CONGESTION_ALGORITHM_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_CUBIC\x10\x01\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_DCTCP\x10\x02\x12\x1e\n\x1a\x43ONGESTION_ALGORITHM_VEGAS\x10\x03\x12\x1f\n\x1b\x43ONGESTION_ALGORITHM_PRAGUE\x10\x04\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR1\x10\x05\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR2\x10\x06\x12\x1d\n\x19\x43ONGESTION_ALGORITHM_BBR3\x10\x07J\x06\x08\xad\x02\x10\xae\x02J\x06\x08\xae\x02\x10\xaf\x02J\x06\x08\xf3\x07\x10\xf4\x07J\x06\x08\xf4\x07\x10\xf5\x07J\x06\x08\xfa\x07\x10\xfb\x07J\x06\x08\xfb\x07\x10\xfc\x07J\x06\x08\xb7\x10\x10\xb8\x10R\x1dinet_diag_msg_socket_dest_asnR!inet_diag_msg_socket_next_hop_asnR\'inet_diag_msg_socket_dest_network_ownerR\"inet_diag_msg_socket_dest_localityR\x1a\x65nrich_socket_next_hop_asnR\x13tcp_info_send_scaleR\x12tcp_info_rcv_scaleR tcp_info_fast_open_client_failedR\x10tcp_info_rtt_varR\x10tcp_info_adv_mssR\x17tcp_info_not_sent_bytesR\x13sk_mem_info_rcv_bufR\x13sk_mem_info_snd_bufR\x12vegas_info_rtt_cntR\x12vegas_info_min_rttR\x1b\x63ongestion_algorithm_stringR\x19\x63ongestion_algorithm_enumR\x0ftype_of_serviceR\rtraffic_classR\x0eshutdown_stateR\x08\x63lass_idR\x08sock_optR\x07\x63_group\"\x14\n\x12\x46latRecordsRequest\"d\n\x13\x46latRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord\"\x18\n\x16PollFlatRecordsRequest\"h\n\x17PollFlatRecordsResponse\x12M\n\x10xtcp_flat_record\x18\x01 \x01(\x0b\x32#.xtcp_flat_record.v1.XtcpFlatRecordR\x0extcpFlatRecord2\xed\x01\n\x15XTCPFlatRecordService\x12\x62\n\x0b\x46latRecords\x12\'.xtcp_flat_record.v1.FlatRecordsRequest\x1a(.xtcp_flat_record.v1.FlatRecordsResponse0\x01\x12p\n\x0fPollFlatRecords\x12+.xtcp_flat_record.v1.PollFlatRecordsRequest\x1a,.xtcp_flat_record.v1.PollFlatRecordsResponse(\x01\x30\x01\x42\xae\x01\n\x17\x63om.xtcp_flat_record.v1B\x13XtcpFlatRecordProtoP\x01Z\x19./gen/go/xtcp_flat_record\xa2\x02\x03XXX\xaa\x02\x11XtcpFlatRecord.V1\xca\x02\x11XtcpFlatRecord\\V1\xe2\x02\x1dXtcpFlatRecord\\V1\\GPBMetadata\xea\x02\x12XtcpFlatRecord::V1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -35,19 +35,19 @@ _globals['_ENVELOPE']._serialized_start=67 _globals['_ENVELOPE']._serialized_end=132 _globals['_XTCPFLATRECORD']._serialized_start=135 - _globals['_XTCPFLATRECORD']._serialized_end=8141 - _globals['_XTCPFLATRECORD_LOCALITY']._serialized_start=7754 - _globals['_XTCPFLATRECORD_LOCALITY']._serialized_end=7857 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=7860 - _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=8141 - _globals['_FLATRECORDSREQUEST']._serialized_start=8143 - _globals['_FLATRECORDSREQUEST']._serialized_end=8163 - _globals['_FLATRECORDSRESPONSE']._serialized_start=8165 - _globals['_FLATRECORDSRESPONSE']._serialized_end=8265 - _globals['_POLLFLATRECORDSREQUEST']._serialized_start=8267 - _globals['_POLLFLATRECORDSREQUEST']._serialized_end=8291 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=8293 - _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=8397 - _globals['_XTCPFLATRECORDSERVICE']._serialized_start=8400 - _globals['_XTCPFLATRECORDSERVICE']._serialized_end=8637 + _globals['_XTCPFLATRECORD']._serialized_end=8910 + _globals['_XTCPFLATRECORD_LOCALITY']._serialized_start=7945 + _globals['_XTCPFLATRECORD_LOCALITY']._serialized_end=8048 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_start=8051 + _globals['_XTCPFLATRECORD_CONGESTIONALGORITHM']._serialized_end=8332 + _globals['_FLATRECORDSREQUEST']._serialized_start=8912 + _globals['_FLATRECORDSREQUEST']._serialized_end=8932 + _globals['_FLATRECORDSRESPONSE']._serialized_start=8934 + _globals['_FLATRECORDSRESPONSE']._serialized_end=9034 + _globals['_POLLFLATRECORDSREQUEST']._serialized_start=9036 + _globals['_POLLFLATRECORDSREQUEST']._serialized_end=9060 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_start=9062 + _globals['_POLLFLATRECORDSRESPONSE']._serialized_end=9166 + _globals['_XTCPFLATRECORDSERVICE']._serialized_start=9169 + _globals['_XTCPFLATRECORDSERVICE']._serialized_end=9406 # @@protoc_insertion_point(module_scope) diff --git a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi index 683ab76..af650d0 100644 --- a/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi +++ b/gen/python/xtcp_flat_record/v1/xtcp_flat_record_pb2.pyi @@ -14,7 +14,7 @@ class Envelope(_message.Message): def __init__(self, row: _Optional[_Iterable[_Union[XtcpFlatRecord, _Mapping]]] = ...) -> None: ... class XtcpFlatRecord(_message.Message): - __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "inet_diag_msg_socket_dest_network_owner", "inet_diag_msg_socket_dest_locality", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_delivery_rate_app_limited", "tcp_info_fast_open_client_failed", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rtt_var", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_adv_mss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_not_sent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "congestion_algorithm_string", "congestion_algorithm_enum", "type_of_service", "traffic_class", "sk_mem_info_rmem_alloc", "sk_mem_info_rcv_buf", "sk_mem_info_wmem_alloc", "sk_mem_info_snd_buf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "shutdown_state", "vegas_info_enabled", "vegas_info_rtt_cnt", "vegas_info_rtt", "vegas_info_min_rtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "class_id", "sock_opt", "c_group") + __slots__ = ("schema_version", "daemon_version", "timestamp_ns", "hostname", "location", "netns", "netns_inode", "nsid", "container_id", "container_runtime", "container_name", "container_image", "label", "tag", "record_counter", "socket_fd", "netlinker_id", "uplink1_ifname", "uplink1_nic_driver", "uplink1_nic_model", "uplink1_nic_pci_vendor", "uplink1_nic_pci_device", "uplink1_nic_bus_info", "uplink1_nic_speed_mbps", "uplink1_nic_fw_version", "uplink1_lldp_chassis_name", "uplink1_lldp_chassis_id", "uplink1_lldp_mgmt_ip", "uplink1_lldp_port_id", "uplink1_lldp_port_descr", "uplink2_ifname", "uplink2_nic_driver", "uplink2_nic_model", "uplink2_nic_pci_vendor", "uplink2_nic_pci_device", "uplink2_nic_bus_info", "uplink2_nic_speed_mbps", "uplink2_nic_fw_version", "uplink2_lldp_chassis_name", "uplink2_lldp_chassis_id", "uplink2_lldp_mgmt_ip", "uplink2_lldp_port_id", "uplink2_lldp_port_descr", "enrich_socket_interface_name", "enrich_socket_dest_locality", "enrich_socket_dest_egress_ifindex", "enrich_socket_dest_egress_ifname", "enrich_socket_dest_asn", "enrich_socket_dest_next_hop_asn", "enrich_socket_dest_network_owner", "inet_diag_msg_family", "inet_diag_msg_state", "inet_diag_msg_timer", "inet_diag_msg_retrans", "inet_diag_msg_socket_source_port", "inet_diag_msg_socket_destination_port", "inet_diag_msg_socket_source", "inet_diag_msg_socket_destination", "inet_diag_msg_socket_interface", "inet_diag_msg_socket_cookie", "inet_diag_msg_expires", "inet_diag_msg_rqueue", "inet_diag_msg_wqueue", "inet_diag_msg_uid", "inet_diag_msg_inode", "mem_info_rmem", "mem_info_wmem", "mem_info_fmem", "mem_info_tmem", "tcp_info_state", "tcp_info_ca_state", "tcp_info_retransmits", "tcp_info_probes", "tcp_info_backoff", "tcp_info_options", "tcp_info_snd_wscale", "tcp_info_rcv_wscale", "tcp_info_delivery_rate_app_limited", "tcp_info_fastopen_client_fail", "tcp_info_rto", "tcp_info_ato", "tcp_info_snd_mss", "tcp_info_rcv_mss", "tcp_info_unacked", "tcp_info_sacked", "tcp_info_lost", "tcp_info_retrans", "tcp_info_fackets", "tcp_info_last_data_sent", "tcp_info_last_ack_sent", "tcp_info_last_data_recv", "tcp_info_last_ack_recv", "tcp_info_pmtu", "tcp_info_rcv_ssthresh", "tcp_info_rtt", "tcp_info_rttvar", "tcp_info_snd_ssthresh", "tcp_info_snd_cwnd", "tcp_info_advmss", "tcp_info_reordering", "tcp_info_rcv_rtt", "tcp_info_rcv_space", "tcp_info_total_retrans", "tcp_info_pacing_rate", "tcp_info_max_pacing_rate", "tcp_info_bytes_acked", "tcp_info_bytes_received", "tcp_info_segs_out", "tcp_info_segs_in", "tcp_info_notsent_bytes", "tcp_info_min_rtt", "tcp_info_data_segs_in", "tcp_info_data_segs_out", "tcp_info_delivery_rate", "tcp_info_busy_time", "tcp_info_rwnd_limited", "tcp_info_sndbuf_limited", "tcp_info_delivered", "tcp_info_delivered_ce", "tcp_info_bytes_sent", "tcp_info_bytes_retrans", "tcp_info_dsack_dups", "tcp_info_reord_seen", "tcp_info_rcv_ooopack", "tcp_info_snd_wnd", "tcp_info_rcv_wnd", "tcp_info_rehash", "tcp_info_total_rto", "tcp_info_total_rto_recoveries", "tcp_info_total_rto_time", "inet_diag_cong", "inet_diag_cong_enum", "inet_diag_tos", "inet_diag_tclass", "sk_mem_info_rmem_alloc", "sk_mem_info_rcvbuf", "sk_mem_info_wmem_alloc", "sk_mem_info_sndbuf", "sk_mem_info_fwd_alloc", "sk_mem_info_wmem_queued", "sk_mem_info_optmem", "sk_mem_info_backlog", "sk_mem_info_drops", "inet_diag_shutdown", "vegas_info_enabled", "vegas_info_rttcnt", "vegas_info_rtt", "vegas_info_minrtt", "dctcp_info_enabled", "dctcp_info_ce_state", "dctcp_info_alpha", "dctcp_info_ab_ecn", "dctcp_info_ab_tot", "bbr_info_bw_lo", "bbr_info_bw_hi", "bbr_info_min_rtt", "bbr_info_pacing_gain", "bbr_info_cwnd_gain", "inet_diag_class_id", "inet_diag_sockopt", "inet_diag_cgroup_id") class Locality(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () LOCALITY_UNSPECIFIED: _ClassVar[XtcpFlatRecord.Locality] @@ -86,6 +86,13 @@ class XtcpFlatRecord(_message.Message): UPLINK2_LLDP_MGMT_IP_FIELD_NUMBER: _ClassVar[int] UPLINK2_LLDP_PORT_ID_FIELD_NUMBER: _ClassVar[int] UPLINK2_LLDP_PORT_DESCR_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_INTERFACE_NAME_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_LOCALITY_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_EGRESS_IFINDEX_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_EGRESS_IFNAME_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_ASN_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_NEXT_HOP_ASN_FIELD_NUMBER: _ClassVar[int] + ENRICH_SOCKET_DEST_NETWORK_OWNER_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_FAMILY_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_STATE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_TIMER_FIELD_NUMBER: _ClassVar[int] @@ -96,15 +103,11 @@ class XtcpFlatRecord(_message.Message): INET_DIAG_MSG_SOCKET_DESTINATION_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_SOCKET_INTERFACE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_SOCKET_COOKIE_FIELD_NUMBER: _ClassVar[int] - INET_DIAG_MSG_SOCKET_DEST_ASN_FIELD_NUMBER: _ClassVar[int] - INET_DIAG_MSG_SOCKET_NEXT_HOP_ASN_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_EXPIRES_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_RQUEUE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_WQUEUE_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_UID_FIELD_NUMBER: _ClassVar[int] INET_DIAG_MSG_INODE_FIELD_NUMBER: _ClassVar[int] - INET_DIAG_MSG_SOCKET_DEST_NETWORK_OWNER_FIELD_NUMBER: _ClassVar[int] - INET_DIAG_MSG_SOCKET_DEST_LOCALITY_FIELD_NUMBER: _ClassVar[int] MEM_INFO_RMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_WMEM_FIELD_NUMBER: _ClassVar[int] MEM_INFO_FMEM_FIELD_NUMBER: _ClassVar[int] @@ -115,10 +118,10 @@ class XtcpFlatRecord(_message.Message): TCP_INFO_PROBES_FIELD_NUMBER: _ClassVar[int] TCP_INFO_BACKOFF_FIELD_NUMBER: _ClassVar[int] TCP_INFO_OPTIONS_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_SEND_SCALE_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_RCV_SCALE_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_SND_WSCALE_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_RCV_WSCALE_FIELD_NUMBER: _ClassVar[int] TCP_INFO_DELIVERY_RATE_APP_LIMITED_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_FAST_OPEN_CLIENT_FAILED_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_FASTOPEN_CLIENT_FAIL_FIELD_NUMBER: _ClassVar[int] TCP_INFO_RTO_FIELD_NUMBER: _ClassVar[int] TCP_INFO_ATO_FIELD_NUMBER: _ClassVar[int] TCP_INFO_SND_MSS_FIELD_NUMBER: _ClassVar[int] @@ -135,10 +138,10 @@ class XtcpFlatRecord(_message.Message): TCP_INFO_PMTU_FIELD_NUMBER: _ClassVar[int] TCP_INFO_RCV_SSTHRESH_FIELD_NUMBER: _ClassVar[int] TCP_INFO_RTT_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_RTT_VAR_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_RTTVAR_FIELD_NUMBER: _ClassVar[int] TCP_INFO_SND_SSTHRESH_FIELD_NUMBER: _ClassVar[int] TCP_INFO_SND_CWND_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_ADV_MSS_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_ADVMSS_FIELD_NUMBER: _ClassVar[int] TCP_INFO_REORDERING_FIELD_NUMBER: _ClassVar[int] TCP_INFO_RCV_RTT_FIELD_NUMBER: _ClassVar[int] TCP_INFO_RCV_SPACE_FIELD_NUMBER: _ClassVar[int] @@ -149,7 +152,7 @@ class XtcpFlatRecord(_message.Message): TCP_INFO_BYTES_RECEIVED_FIELD_NUMBER: _ClassVar[int] TCP_INFO_SEGS_OUT_FIELD_NUMBER: _ClassVar[int] TCP_INFO_SEGS_IN_FIELD_NUMBER: _ClassVar[int] - TCP_INFO_NOT_SENT_BYTES_FIELD_NUMBER: _ClassVar[int] + TCP_INFO_NOTSENT_BYTES_FIELD_NUMBER: _ClassVar[int] TCP_INFO_MIN_RTT_FIELD_NUMBER: _ClassVar[int] TCP_INFO_DATA_SEGS_IN_FIELD_NUMBER: _ClassVar[int] TCP_INFO_DATA_SEGS_OUT_FIELD_NUMBER: _ClassVar[int] @@ -170,24 +173,24 @@ class XtcpFlatRecord(_message.Message): TCP_INFO_TOTAL_RTO_FIELD_NUMBER: _ClassVar[int] TCP_INFO_TOTAL_RTO_RECOVERIES_FIELD_NUMBER: _ClassVar[int] TCP_INFO_TOTAL_RTO_TIME_FIELD_NUMBER: _ClassVar[int] - CONGESTION_ALGORITHM_STRING_FIELD_NUMBER: _ClassVar[int] - CONGESTION_ALGORITHM_ENUM_FIELD_NUMBER: _ClassVar[int] - TYPE_OF_SERVICE_FIELD_NUMBER: _ClassVar[int] - TRAFFIC_CLASS_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_CONG_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_CONG_ENUM_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_TOS_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_TCLASS_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_RMEM_ALLOC_FIELD_NUMBER: _ClassVar[int] - SK_MEM_INFO_RCV_BUF_FIELD_NUMBER: _ClassVar[int] + SK_MEM_INFO_RCVBUF_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_WMEM_ALLOC_FIELD_NUMBER: _ClassVar[int] - SK_MEM_INFO_SND_BUF_FIELD_NUMBER: _ClassVar[int] + SK_MEM_INFO_SNDBUF_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_FWD_ALLOC_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_WMEM_QUEUED_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_OPTMEM_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_BACKLOG_FIELD_NUMBER: _ClassVar[int] SK_MEM_INFO_DROPS_FIELD_NUMBER: _ClassVar[int] - SHUTDOWN_STATE_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_SHUTDOWN_FIELD_NUMBER: _ClassVar[int] VEGAS_INFO_ENABLED_FIELD_NUMBER: _ClassVar[int] - VEGAS_INFO_RTT_CNT_FIELD_NUMBER: _ClassVar[int] + VEGAS_INFO_RTTCNT_FIELD_NUMBER: _ClassVar[int] VEGAS_INFO_RTT_FIELD_NUMBER: _ClassVar[int] - VEGAS_INFO_MIN_RTT_FIELD_NUMBER: _ClassVar[int] + VEGAS_INFO_MINRTT_FIELD_NUMBER: _ClassVar[int] DCTCP_INFO_ENABLED_FIELD_NUMBER: _ClassVar[int] DCTCP_INFO_CE_STATE_FIELD_NUMBER: _ClassVar[int] DCTCP_INFO_ALPHA_FIELD_NUMBER: _ClassVar[int] @@ -198,9 +201,9 @@ class XtcpFlatRecord(_message.Message): BBR_INFO_MIN_RTT_FIELD_NUMBER: _ClassVar[int] BBR_INFO_PACING_GAIN_FIELD_NUMBER: _ClassVar[int] BBR_INFO_CWND_GAIN_FIELD_NUMBER: _ClassVar[int] - CLASS_ID_FIELD_NUMBER: _ClassVar[int] - SOCK_OPT_FIELD_NUMBER: _ClassVar[int] - C_GROUP_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_CLASS_ID_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_SOCKOPT_FIELD_NUMBER: _ClassVar[int] + INET_DIAG_CGROUP_ID_FIELD_NUMBER: _ClassVar[int] schema_version: int daemon_version: str timestamp_ns: int @@ -244,6 +247,13 @@ class XtcpFlatRecord(_message.Message): uplink2_lldp_mgmt_ip: str uplink2_lldp_port_id: str uplink2_lldp_port_descr: str + enrich_socket_interface_name: str + enrich_socket_dest_locality: XtcpFlatRecord.Locality + enrich_socket_dest_egress_ifindex: int + enrich_socket_dest_egress_ifname: str + enrich_socket_dest_asn: int + enrich_socket_dest_next_hop_asn: int + enrich_socket_dest_network_owner: str inet_diag_msg_family: int inet_diag_msg_state: int inet_diag_msg_timer: int @@ -254,15 +264,11 @@ class XtcpFlatRecord(_message.Message): inet_diag_msg_socket_destination: bytes inet_diag_msg_socket_interface: int inet_diag_msg_socket_cookie: int - inet_diag_msg_socket_dest_asn: int - inet_diag_msg_socket_next_hop_asn: int inet_diag_msg_expires: int inet_diag_msg_rqueue: int inet_diag_msg_wqueue: int inet_diag_msg_uid: int inet_diag_msg_inode: int - inet_diag_msg_socket_dest_network_owner: str - inet_diag_msg_socket_dest_locality: XtcpFlatRecord.Locality mem_info_rmem: int mem_info_wmem: int mem_info_fmem: int @@ -273,10 +279,10 @@ class XtcpFlatRecord(_message.Message): tcp_info_probes: int tcp_info_backoff: int tcp_info_options: int - tcp_info_send_scale: int - tcp_info_rcv_scale: int + tcp_info_snd_wscale: int + tcp_info_rcv_wscale: int tcp_info_delivery_rate_app_limited: int - tcp_info_fast_open_client_failed: int + tcp_info_fastopen_client_fail: int tcp_info_rto: int tcp_info_ato: int tcp_info_snd_mss: int @@ -293,10 +299,10 @@ class XtcpFlatRecord(_message.Message): tcp_info_pmtu: int tcp_info_rcv_ssthresh: int tcp_info_rtt: int - tcp_info_rtt_var: int + tcp_info_rttvar: int tcp_info_snd_ssthresh: int tcp_info_snd_cwnd: int - tcp_info_adv_mss: int + tcp_info_advmss: int tcp_info_reordering: int tcp_info_rcv_rtt: int tcp_info_rcv_space: int @@ -307,7 +313,7 @@ class XtcpFlatRecord(_message.Message): tcp_info_bytes_received: int tcp_info_segs_out: int tcp_info_segs_in: int - tcp_info_not_sent_bytes: int + tcp_info_notsent_bytes: int tcp_info_min_rtt: int tcp_info_data_segs_in: int tcp_info_data_segs_out: int @@ -328,24 +334,24 @@ class XtcpFlatRecord(_message.Message): tcp_info_total_rto: int tcp_info_total_rto_recoveries: int tcp_info_total_rto_time: int - congestion_algorithm_string: str - congestion_algorithm_enum: XtcpFlatRecord.CongestionAlgorithm - type_of_service: int - traffic_class: int + inet_diag_cong: str + inet_diag_cong_enum: XtcpFlatRecord.CongestionAlgorithm + inet_diag_tos: int + inet_diag_tclass: int sk_mem_info_rmem_alloc: int - sk_mem_info_rcv_buf: int + sk_mem_info_rcvbuf: int sk_mem_info_wmem_alloc: int - sk_mem_info_snd_buf: int + sk_mem_info_sndbuf: int sk_mem_info_fwd_alloc: int sk_mem_info_wmem_queued: int sk_mem_info_optmem: int sk_mem_info_backlog: int sk_mem_info_drops: int - shutdown_state: int + inet_diag_shutdown: int vegas_info_enabled: int - vegas_info_rtt_cnt: int + vegas_info_rttcnt: int vegas_info_rtt: int - vegas_info_min_rtt: int + vegas_info_minrtt: int dctcp_info_enabled: int dctcp_info_ce_state: int dctcp_info_alpha: int @@ -356,10 +362,10 @@ class XtcpFlatRecord(_message.Message): bbr_info_min_rtt: int bbr_info_pacing_gain: int bbr_info_cwnd_gain: int - class_id: int - sock_opt: int - c_group: int - def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_socket_dest_asn: _Optional[int] = ..., inet_diag_msg_socket_next_hop_asn: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., inet_diag_msg_socket_dest_network_owner: _Optional[str] = ..., inet_diag_msg_socket_dest_locality: _Optional[_Union[XtcpFlatRecord.Locality, str]] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_send_scale: _Optional[int] = ..., tcp_info_rcv_scale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fast_open_client_failed: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rtt_var: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_adv_mss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_not_sent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., congestion_algorithm_string: _Optional[str] = ..., congestion_algorithm_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., type_of_service: _Optional[int] = ..., traffic_class: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcv_buf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_snd_buf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., shutdown_state: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rtt_cnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_min_rtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., class_id: _Optional[int] = ..., sock_opt: _Optional[int] = ..., c_group: _Optional[int] = ...) -> None: ... + inet_diag_class_id: int + inet_diag_sockopt: int + inet_diag_cgroup_id: int + def __init__(self, schema_version: _Optional[int] = ..., daemon_version: _Optional[str] = ..., timestamp_ns: _Optional[int] = ..., hostname: _Optional[str] = ..., location: _Optional[str] = ..., netns: _Optional[str] = ..., netns_inode: _Optional[int] = ..., nsid: _Optional[int] = ..., container_id: _Optional[str] = ..., container_runtime: _Optional[str] = ..., container_name: _Optional[str] = ..., container_image: _Optional[str] = ..., label: _Optional[str] = ..., tag: _Optional[str] = ..., record_counter: _Optional[int] = ..., socket_fd: _Optional[int] = ..., netlinker_id: _Optional[int] = ..., uplink1_ifname: _Optional[str] = ..., uplink1_nic_driver: _Optional[str] = ..., uplink1_nic_model: _Optional[str] = ..., uplink1_nic_pci_vendor: _Optional[int] = ..., uplink1_nic_pci_device: _Optional[int] = ..., uplink1_nic_bus_info: _Optional[str] = ..., uplink1_nic_speed_mbps: _Optional[int] = ..., uplink1_nic_fw_version: _Optional[str] = ..., uplink1_lldp_chassis_name: _Optional[str] = ..., uplink1_lldp_chassis_id: _Optional[str] = ..., uplink1_lldp_mgmt_ip: _Optional[str] = ..., uplink1_lldp_port_id: _Optional[str] = ..., uplink1_lldp_port_descr: _Optional[str] = ..., uplink2_ifname: _Optional[str] = ..., uplink2_nic_driver: _Optional[str] = ..., uplink2_nic_model: _Optional[str] = ..., uplink2_nic_pci_vendor: _Optional[int] = ..., uplink2_nic_pci_device: _Optional[int] = ..., uplink2_nic_bus_info: _Optional[str] = ..., uplink2_nic_speed_mbps: _Optional[int] = ..., uplink2_nic_fw_version: _Optional[str] = ..., uplink2_lldp_chassis_name: _Optional[str] = ..., uplink2_lldp_chassis_id: _Optional[str] = ..., uplink2_lldp_mgmt_ip: _Optional[str] = ..., uplink2_lldp_port_id: _Optional[str] = ..., uplink2_lldp_port_descr: _Optional[str] = ..., enrich_socket_interface_name: _Optional[str] = ..., enrich_socket_dest_locality: _Optional[_Union[XtcpFlatRecord.Locality, str]] = ..., enrich_socket_dest_egress_ifindex: _Optional[int] = ..., enrich_socket_dest_egress_ifname: _Optional[str] = ..., enrich_socket_dest_asn: _Optional[int] = ..., enrich_socket_dest_next_hop_asn: _Optional[int] = ..., enrich_socket_dest_network_owner: _Optional[str] = ..., inet_diag_msg_family: _Optional[int] = ..., inet_diag_msg_state: _Optional[int] = ..., inet_diag_msg_timer: _Optional[int] = ..., inet_diag_msg_retrans: _Optional[int] = ..., inet_diag_msg_socket_source_port: _Optional[int] = ..., inet_diag_msg_socket_destination_port: _Optional[int] = ..., inet_diag_msg_socket_source: _Optional[bytes] = ..., inet_diag_msg_socket_destination: _Optional[bytes] = ..., inet_diag_msg_socket_interface: _Optional[int] = ..., inet_diag_msg_socket_cookie: _Optional[int] = ..., inet_diag_msg_expires: _Optional[int] = ..., inet_diag_msg_rqueue: _Optional[int] = ..., inet_diag_msg_wqueue: _Optional[int] = ..., inet_diag_msg_uid: _Optional[int] = ..., inet_diag_msg_inode: _Optional[int] = ..., mem_info_rmem: _Optional[int] = ..., mem_info_wmem: _Optional[int] = ..., mem_info_fmem: _Optional[int] = ..., mem_info_tmem: _Optional[int] = ..., tcp_info_state: _Optional[int] = ..., tcp_info_ca_state: _Optional[int] = ..., tcp_info_retransmits: _Optional[int] = ..., tcp_info_probes: _Optional[int] = ..., tcp_info_backoff: _Optional[int] = ..., tcp_info_options: _Optional[int] = ..., tcp_info_snd_wscale: _Optional[int] = ..., tcp_info_rcv_wscale: _Optional[int] = ..., tcp_info_delivery_rate_app_limited: _Optional[int] = ..., tcp_info_fastopen_client_fail: _Optional[int] = ..., tcp_info_rto: _Optional[int] = ..., tcp_info_ato: _Optional[int] = ..., tcp_info_snd_mss: _Optional[int] = ..., tcp_info_rcv_mss: _Optional[int] = ..., tcp_info_unacked: _Optional[int] = ..., tcp_info_sacked: _Optional[int] = ..., tcp_info_lost: _Optional[int] = ..., tcp_info_retrans: _Optional[int] = ..., tcp_info_fackets: _Optional[int] = ..., tcp_info_last_data_sent: _Optional[int] = ..., tcp_info_last_ack_sent: _Optional[int] = ..., tcp_info_last_data_recv: _Optional[int] = ..., tcp_info_last_ack_recv: _Optional[int] = ..., tcp_info_pmtu: _Optional[int] = ..., tcp_info_rcv_ssthresh: _Optional[int] = ..., tcp_info_rtt: _Optional[int] = ..., tcp_info_rttvar: _Optional[int] = ..., tcp_info_snd_ssthresh: _Optional[int] = ..., tcp_info_snd_cwnd: _Optional[int] = ..., tcp_info_advmss: _Optional[int] = ..., tcp_info_reordering: _Optional[int] = ..., tcp_info_rcv_rtt: _Optional[int] = ..., tcp_info_rcv_space: _Optional[int] = ..., tcp_info_total_retrans: _Optional[int] = ..., tcp_info_pacing_rate: _Optional[int] = ..., tcp_info_max_pacing_rate: _Optional[int] = ..., tcp_info_bytes_acked: _Optional[int] = ..., tcp_info_bytes_received: _Optional[int] = ..., tcp_info_segs_out: _Optional[int] = ..., tcp_info_segs_in: _Optional[int] = ..., tcp_info_notsent_bytes: _Optional[int] = ..., tcp_info_min_rtt: _Optional[int] = ..., tcp_info_data_segs_in: _Optional[int] = ..., tcp_info_data_segs_out: _Optional[int] = ..., tcp_info_delivery_rate: _Optional[int] = ..., tcp_info_busy_time: _Optional[int] = ..., tcp_info_rwnd_limited: _Optional[int] = ..., tcp_info_sndbuf_limited: _Optional[int] = ..., tcp_info_delivered: _Optional[int] = ..., tcp_info_delivered_ce: _Optional[int] = ..., tcp_info_bytes_sent: _Optional[int] = ..., tcp_info_bytes_retrans: _Optional[int] = ..., tcp_info_dsack_dups: _Optional[int] = ..., tcp_info_reord_seen: _Optional[int] = ..., tcp_info_rcv_ooopack: _Optional[int] = ..., tcp_info_snd_wnd: _Optional[int] = ..., tcp_info_rcv_wnd: _Optional[int] = ..., tcp_info_rehash: _Optional[int] = ..., tcp_info_total_rto: _Optional[int] = ..., tcp_info_total_rto_recoveries: _Optional[int] = ..., tcp_info_total_rto_time: _Optional[int] = ..., inet_diag_cong: _Optional[str] = ..., inet_diag_cong_enum: _Optional[_Union[XtcpFlatRecord.CongestionAlgorithm, str]] = ..., inet_diag_tos: _Optional[int] = ..., inet_diag_tclass: _Optional[int] = ..., sk_mem_info_rmem_alloc: _Optional[int] = ..., sk_mem_info_rcvbuf: _Optional[int] = ..., sk_mem_info_wmem_alloc: _Optional[int] = ..., sk_mem_info_sndbuf: _Optional[int] = ..., sk_mem_info_fwd_alloc: _Optional[int] = ..., sk_mem_info_wmem_queued: _Optional[int] = ..., sk_mem_info_optmem: _Optional[int] = ..., sk_mem_info_backlog: _Optional[int] = ..., sk_mem_info_drops: _Optional[int] = ..., inet_diag_shutdown: _Optional[int] = ..., vegas_info_enabled: _Optional[int] = ..., vegas_info_rttcnt: _Optional[int] = ..., vegas_info_rtt: _Optional[int] = ..., vegas_info_minrtt: _Optional[int] = ..., dctcp_info_enabled: _Optional[int] = ..., dctcp_info_ce_state: _Optional[int] = ..., dctcp_info_alpha: _Optional[int] = ..., dctcp_info_ab_ecn: _Optional[int] = ..., dctcp_info_ab_tot: _Optional[int] = ..., bbr_info_bw_lo: _Optional[int] = ..., bbr_info_bw_hi: _Optional[int] = ..., bbr_info_min_rtt: _Optional[int] = ..., bbr_info_pacing_gain: _Optional[int] = ..., bbr_info_cwnd_gain: _Optional[int] = ..., inet_diag_class_id: _Optional[int] = ..., inet_diag_sockopt: _Optional[int] = ..., inet_diag_cgroup_id: _Optional[int] = ...) -> None: ... class FlatRecordsRequest(_message.Message): __slots__ = () diff --git a/go.mod b/go.mod index 9881093..5709901 100644 --- a/go.mod +++ b/go.mod @@ -14,7 +14,7 @@ require ( github.com/parquet-go/parquet-go v0.32.0 github.com/pkg/profile v1.7.0 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 - github.com/prometheus/client_golang v1.22.0 + github.com/prometheus/client_golang v1.24.1 github.com/prometheus/client_model v0.6.2 github.com/randomizedcoder/giouring v0.0.0-00010101000000-000000000000 github.com/redis/go-redis/v9 v9.7.3 @@ -25,6 +25,7 @@ require ( go.opentelemetry.io/otel v1.46.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 + go.opentelemetry.io/otel/exporters/prometheus v0.68.0 go.opentelemetry.io/otel/metric v1.46.0 go.opentelemetry.io/otel/sdk v1.46.0 go.opentelemetry.io/otel/sdk/metric v1.46.0 @@ -66,8 +67,9 @@ require ( github.com/parquet-go/jsonlite v1.0.0 // indirect github.com/philhofer/fwd v1.2.0 // indirect github.com/pierrec/lz4/v4 v4.1.22 // indirect - github.com/prometheus/common v0.63.0 // indirect - github.com/prometheus/procfs v0.16.0 // indirect + github.com/prometheus/common v0.70.1 // indirect + github.com/prometheus/otlptranslator v1.0.0 // indirect + github.com/prometheus/procfs v0.21.1 // indirect github.com/rs/xid v1.6.0 // indirect github.com/stoewer/go-strcase v1.3.0 // indirect github.com/tinylib/msgp v1.6.4 // indirect diff --git a/go.sum b/go.sum index 6a298a4..c0227c7 100644 --- a/go.sum +++ b/go.sum @@ -123,14 +123,16 @@ github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDj github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q= -github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k= -github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18= -github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2bbsM= -github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= +github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= +github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= +github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= +github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM= github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= @@ -181,6 +183,8 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 h1:OFnwLJr+pF3iHrlGSzb go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0/go.mod h1:716wFneO0ov19A2beH5hjfh9AK5z/VWNAtDijp1Y0/g= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 h1:KrC1YrQeSt46ITMWAbgQx1M1eV1/1TKzttrBzymPmss= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0/go.mod h1:zDSEzoEqsOrgBeGvH66KRgxh90VonFyJqBHA0Pk3+rM= +go.opentelemetry.io/otel/exporters/prometheus v0.68.0 h1:QOf2IftqQwITVRJpnn0M7M9ZCbgWfxz4P7i9C9yc2N4= +go.opentelemetry.io/otel/exporters/prometheus v0.68.0/go.mod h1:bgSvqu2TWGXiz7yr5UTMfObH8oqxJWHTnubQ3ef9BO4= go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= @@ -195,6 +199,8 @@ go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6Tb go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= +go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= diff --git a/internal/ipfeed/asnmap/asnmap_test.go b/internal/ipfeed/asnmap/asnmap_test.go index 0ae0cd3..1ba9cff 100644 --- a/internal/ipfeed/asnmap/asnmap_test.go +++ b/internal/ipfeed/asnmap/asnmap_test.go @@ -38,20 +38,90 @@ func TestLookup(t *testing.T) { } } -// TestAnnotate verifies in-place ASN annotation across known and unknown owners. +// TestAnnotate verifies in-place ASN annotation across known and unknown +// owners. expectedASNs is index-aligned with records. func TestAnnotate(t *testing.T) { - recs := []model.Record{ - {Prefix: "1.1.1.0/24", NetworkOwner: "cloudflare"}, // known - {Prefix: "8.8.8.0/24", Provider: "gcp"}, // known via provider - {Prefix: "10.0.0.0/24", NetworkOwner: "acme"}, // unknown -> 0 - {Prefix: "192.0.2.0/24", NetworkOwner: "", Provider: ""}, // empty -> 0 + tests := []struct { + description string + records []model.Record + expectedASNs []uint32 + }{ + // positive + { + description: "positive: a known network_owner is annotated", + records: []model.Record{{Prefix: "1.1.1.0/24", NetworkOwner: "cloudflare"}}, + expectedASNs: []uint32{13335}, + }, + { + description: "positive: falls back to provider when owner is empty", + records: []model.Record{{Prefix: "8.8.8.0/24", Provider: "gcp"}}, + expectedASNs: []uint32{15169}, + }, + { + description: "positive: a mixed slice is annotated element-wise in place", + records: []model.Record{ + {Prefix: "1.1.1.0/24", NetworkOwner: "cloudflare"}, + {Prefix: "8.8.8.0/24", Provider: "gcp"}, + {Prefix: "10.0.0.0/24", NetworkOwner: "acme"}, + {Prefix: "192.0.2.0/24", NetworkOwner: "", Provider: ""}, + }, + expectedASNs: []uint32{13335, 15169, 0, 0}, + }, + // negative + { + description: "negative: an unknown owner and provider stays at 0", + records: []model.Record{{Prefix: "10.0.0.0/24", NetworkOwner: "acme", Provider: "acme"}}, + expectedASNs: []uint32{0}, + }, + // boundary + { + description: "boundary: empty owner and provider stays at 0", + records: []model.Record{{Prefix: "192.0.2.0/24", NetworkOwner: "", Provider: ""}}, + expectedASNs: []uint32{0}, + }, + { + description: "boundary: an empty slice is a no-op", + records: []model.Record{}, + expectedASNs: []uint32{}, + }, + { + description: "boundary: a nil slice is a no-op", + records: nil, + expectedASNs: nil, + }, + // corner + { + description: "corner: owner wins over a conflicting provider", + records: []model.Record{{Prefix: "151.101.0.0/16", NetworkOwner: "fastly", Provider: "aws"}}, + expectedASNs: []uint32{54113}, + }, + { + description: "corner: an unknown record's pre-existing ASN is left untouched, not reset", + records: []model.Record{{Prefix: "10.0.0.0/24", NetworkOwner: "acme", ASN: 64512}}, + expectedASNs: []uint32{64512}, + }, + { + description: "corner: a known record's pre-existing ASN is overwritten", + records: []model.Record{{Prefix: "1.1.1.0/24", NetworkOwner: "cloudflare", ASN: 64512}}, + expectedASNs: []uint32{13335}, + }, + { + description: "corner: matching is case- and whitespace-insensitive", + records: []model.Record{{Prefix: "1.1.1.0/24", NetworkOwner: " CloudFlare "}}, + expectedASNs: []uint32{13335}, + }, } - Annotate(recs) - - want := []uint32{13335, 15169, 0, 0} - for i, w := range want { - if recs[i].ASN != w { - t.Errorf("record %d (%s): ASN = %d, want %d", i, recs[i].Prefix, recs[i].ASN, w) - } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + Annotate(tc.records) + if len(tc.records) != len(tc.expectedASNs) { + t.Fatalf("%s: test row malformed: %d records vs %d expected ASNs", tc.description, len(tc.records), len(tc.expectedASNs)) + } + for i, want := range tc.expectedASNs { + if got := tc.records[i].ASN; got != want { + t.Errorf("%s: record %d (%s): ASN = %d, want %d", tc.description, i, tc.records[i].Prefix, got, want) + } + } + }) } } diff --git a/internal/ipfeed/config/source.go b/internal/ipfeed/config/source.go index fa3ec6c..bab5756 100644 --- a/internal/ipfeed/config/source.go +++ b/internal/ipfeed/config/source.go @@ -4,7 +4,9 @@ package config import ( + "errors" "fmt" + "io/fs" "os" "path/filepath" "sort" @@ -112,8 +114,20 @@ func LoadFile(path string) (Source, error) { // LoadDir loads every *.yaml / *.yml file in dir, returning only enabled // sources sorted by name. A parse/validation error in any file is returned so -// a broken config fails fast rather than silently dropping a feed. +// a broken config fails fast rather than silently dropping a feed. The +// directory is stat'ed first so a missing or wrong -sources-dir produces a +// clear error instead of an empty glob that looks like "no sources". func LoadDir(dir string) ([]Source, error) { + fi, err := os.Stat(dir) + switch { + case errors.Is(err, fs.ErrNotExist): + return nil, fmt.Errorf("sources dir %s: not found", dir) + case err != nil: + return nil, fmt.Errorf("sources dir %s: %w", dir, err) + case !fi.IsDir(): + return nil, fmt.Errorf("sources dir %s: not a directory", dir) + } + var paths []string for _, pat := range []string{"*.yaml", "*.yml"} { m, err := filepath.Glob(filepath.Join(dir, pat)) diff --git a/internal/ipfeed/config/source_test.go b/internal/ipfeed/config/source_test.go index ca9ce46..f6730d4 100644 --- a/internal/ipfeed/config/source_test.go +++ b/internal/ipfeed/config/source_test.go @@ -1,8 +1,11 @@ package config import ( + "fmt" "os" "path/filepath" + "slices" + "strings" "testing" // Import parse so its parsers register via init(), making parser keys like @@ -55,40 +58,167 @@ func TestLoadFile(t *testing.T) { } } +// TestLoadDir covers directory-level loading: the up-front stat of the +// sources dir, file globbing, enabled filtering, ordering, and cross-file +// duplicate detection. Each row's setup builds the directory (or non-directory) +// to load and returns the path to pass to LoadDir. func TestLoadDir(t *testing.T) { - t.Run("positive_enabled_only_sorted", func(t *testing.T) { - dir := t.TempDir() - writeFile(t, dir, "b.yaml", "name: bbb\nurl: https://x\nparser: text_cidr\n") - writeFile(t, dir, "a.yaml", "name: aaa\nurl: https://x\nparser: text_cidr\n") - writeFile(t, dir, "off.yaml", "name: ccc\nurl: https://x\nparser: text_cidr\nenabled: false\n") - got, err := LoadDir(dir) - if err != nil { - t.Fatal(err) - } - if len(got) != 2 { - t.Fatalf("got %d sources, want 2 (disabled excluded)", len(got)) - } - if got[0].Name != "aaa" || got[1].Name != "bbb" { - t.Errorf("not sorted by name: %q, %q", got[0].Name, got[1].Name) - } - }) + const valid = "name: %s\nurl: https://x\nparser: text_cidr\n" - t.Run("negative_duplicate_name", func(t *testing.T) { - dir := t.TempDir() - writeFile(t, dir, "one.yaml", "name: dup\nurl: https://x\nparser: csv\n") - writeFile(t, dir, "two.yaml", "name: dup\nurl: https://y\nparser: csv\n") - if _, err := LoadDir(dir); err == nil { - t.Fatal("expected duplicate-name error, got nil") - } - }) - - t.Run("boundary_empty_dir", func(t *testing.T) { - got, err := LoadDir(t.TempDir()) - if err != nil { - t.Fatal(err) - } - if len(got) != 0 { - t.Fatalf("got %d, want 0", len(got)) - } - }) + tests := []struct { + description string + setup func(t *testing.T) string // returns the path handed to LoadDir + expectErr bool + expectErrText string // substring the error must contain (when expectErr) + expectNames []string // enabled source names, in returned order (when !expectErr) + }{ + // positive + { + description: "positive: a dir with one valid yaml loads that source", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "cf.yaml", fmt.Sprintf(valid, "cloudflare")) + return dir + }, + expectNames: []string{"cloudflare"}, + }, + { + description: "positive: multiple files load sorted by source name, disabled ones excluded", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "b.yaml", fmt.Sprintf(valid, "bbb")) + writeFile(t, dir, "a.yaml", fmt.Sprintf(valid, "aaa")) + writeFile(t, dir, "off.yaml", fmt.Sprintf(valid, "ccc")+"enabled: false\n") + return dir + }, + expectNames: []string{"aaa", "bbb"}, + }, + // negative + { + description: "negative: a missing dir errors with a clear 'not found'", + setup: func(t *testing.T) string { + return filepath.Join(t.TempDir(), "does-not-exist") + }, + expectErr: true, + expectErrText: "not found", + }, + { + description: "negative: a path that is a file, not a dir, errors with 'not a directory'", + setup: func(t *testing.T) string { + return writeFile(t, t.TempDir(), "sources.yaml", fmt.Sprintf(valid, "x")) + }, + expectErr: true, + expectErrText: "not a directory", + }, + { + description: "negative: a dir containing an invalid yaml fails the whole load (fail fast)", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "good.yaml", fmt.Sprintf(valid, "good")) + writeFile(t, dir, "bad.yaml", "name: bad\nurl: https://x\nparser: nope_parser\n") + return dir + }, + expectErr: true, + expectErrText: "unknown parser", + }, + { + description: "negative: malformed yaml syntax fails the load", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "broken.yaml", "name: [unterminated\n") + return dir + }, + expectErr: true, + expectErrText: "decode", + }, + { + description: "negative: two files sharing a source name are rejected as duplicates", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "one.yaml", "name: dup\nurl: https://x\nparser: csv\n") + writeFile(t, dir, "two.yaml", "name: dup\nurl: https://y\nparser: csv\n") + return dir + }, + expectErr: true, + expectErrText: "duplicate source name", + }, + // boundary + { + description: "boundary: an empty dir loads zero sources without error", + setup: func(t *testing.T) string { return t.TempDir() }, + expectNames: nil, + }, + { + description: "boundary: a dir whose only source is disabled loads zero sources", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "off.yaml", fmt.Sprintf(valid, "off")+"enabled: false\n") + return dir + }, + expectNames: nil, + }, + // corner + { + description: "corner: .yml files are picked up alongside .yaml", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "a.yml", fmt.Sprintf(valid, "yml-source")) + writeFile(t, dir, "b.yaml", fmt.Sprintf(valid, "yaml-source")) + return dir + }, + expectNames: []string{"yaml-source", "yml-source"}, + }, + { + description: "corner: non-yaml files in the dir are ignored, not parsed", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "README.md", "# not yaml at all\n") + writeFile(t, dir, "notes.txt", "name: [broken\n") + writeFile(t, dir, "ok.yaml", fmt.Sprintf(valid, "ok")) + return dir + }, + expectNames: []string{"ok"}, + }, + { + description: "corner: a disabled duplicate still counts as a duplicate name", + setup: func(t *testing.T) string { + dir := t.TempDir() + writeFile(t, dir, "one.yaml", fmt.Sprintf(valid, "dup")) + writeFile(t, dir, "two.yaml", fmt.Sprintf(valid, "dup")+"enabled: false\n") + return dir + }, + expectErr: true, + expectErrText: "duplicate source name", + }, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + path := tc.setup(t) + got, err := LoadDir(path) + if tc.expectErr { + if err == nil { + t.Fatalf("expected error containing %q, got nil (loaded %d sources)", tc.expectErrText, len(got)) + } + if !strings.Contains(err.Error(), tc.expectErrText) { + t.Fatalf("error %q does not contain %q", err.Error(), tc.expectErrText) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + var names []string + for _, s := range got { + names = append(names, s.Name) + } + if !slices.Equal(names, tc.expectNames) { + t.Errorf("source names = %q, want %q", names, tc.expectNames) + } + for _, s := range got { + if s.Path == "" { + t.Errorf("source %q: Path not recorded for diagnostics", s.Name) + } + } + }) + } } diff --git a/internal/ipfeed/fetch/fetch.go b/internal/ipfeed/fetch/fetch.go index 9e48ebb..6218735 100644 --- a/internal/ipfeed/fetch/fetch.go +++ b/internal/ipfeed/fetch/fetch.go @@ -15,6 +15,19 @@ import ( "time" ) +// maxBodyBytes caps how much of a 2xx response body Get will buffer. The +// largest real feed (Azure Service Tags) is a few MiB, so 256 MiB is far above +// anything legitimate while still bounding memory if a feed URL starts +// returning garbage (a redirect to a video, a runaway endpoint, …). A body +// that exceeds the cap fails the fetch with ErrBodyTooLarge and is not +// retried. It is a variable (not a const) only so tests can lower it instead +// of streaming hundreds of MiB through httptest. +var maxBodyBytes int64 = 256 << 20 + +// ErrBodyTooLarge is returned (wrapped) when a response body exceeds +// maxBodyBytes. Match it with errors.Is. +var ErrBodyTooLarge = errors.New("response body exceeds size limit") + // Result is the outcome of a successful (or not-modified) fetch. type Result struct { URL string @@ -162,10 +175,17 @@ func (c *Client) attempt(ctx context.Context, url string, cond Conditional) (Res res.NotModified = true return res, false, nil case resp.StatusCode >= 200 && resp.StatusCode < 300: - body, err := io.ReadAll(resp.Body) + // Read at most limit+1 bytes: exactly `limit` bytes is accepted, and + // the one extra byte is how we detect that the body kept going without + // buffering all of it. + body, err := io.ReadAll(io.LimitReader(resp.Body, maxBodyBytes+1)) if err != nil { return res, true, err // truncated read: retry } + if int64(len(body)) > maxBodyBytes { + // A feed this large will be just as large on retry; fail fast. + return res, false, fmt.Errorf("%w (limit %d bytes)", ErrBodyTooLarge, maxBodyBytes) + } res.Body = body return res, false, nil case resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500: diff --git a/internal/ipfeed/fetch/fetch_test.go b/internal/ipfeed/fetch/fetch_test.go index 4296ecf..6ababa8 100644 --- a/internal/ipfeed/fetch/fetch_test.go +++ b/internal/ipfeed/fetch/fetch_test.go @@ -1,7 +1,9 @@ package fetch import ( + "bytes" "context" + "errors" "net/http" "net/http/httptest" "testing" @@ -87,6 +89,77 @@ func TestGet(t *testing.T) { } } +// TestGetBodyLimit covers the response-body size cap. The package-level +// maxBodyBytes is lowered for the test (and restored via t.Cleanup) so the +// boundary can be exercised with a few KiB rather than 256 MiB over httptest. +func TestGetBodyLimit(t *testing.T) { + const limit = 4096 + prev := maxBodyBytes + maxBodyBytes = limit + t.Cleanup(func() { maxBodyBytes = prev }) + + tests := []struct { + description string + bodySize int + maxAttempts int + expectErr bool + expectTooBig bool // errors.Is(err, ErrBodyTooLarge) + expectBodyLen int // only checked when !expectErr + expectCalls int // server hits: an over-limit body must not be retried + }{ + // positive + {description: "positive: a small body under the limit is returned whole", + bodySize: 10, maxAttempts: 3, expectErr: false, expectBodyLen: 10, expectCalls: 1}, + {description: "positive: a body well under the limit is returned whole", + bodySize: limit / 2, maxAttempts: 3, expectErr: false, expectBodyLen: limit / 2, expectCalls: 1}, + // negative + {description: "negative: a body far over the limit fails with ErrBodyTooLarge", + bodySize: limit * 4, maxAttempts: 3, expectErr: true, expectTooBig: true, expectCalls: 1}, + // boundary + {description: "boundary: a body exactly at the limit is accepted", + bodySize: limit, maxAttempts: 3, expectErr: false, expectBodyLen: limit, expectCalls: 1}, + {description: "boundary: a body one byte over the limit is rejected", + bodySize: limit + 1, maxAttempts: 3, expectErr: true, expectTooBig: true, expectCalls: 1}, + {description: "boundary: an empty 200 body is accepted (zero bytes)", + bodySize: 0, maxAttempts: 3, expectErr: false, expectBodyLen: 0, expectCalls: 1}, + // corner + {description: "corner: an over-limit body is not retried even with attempts remaining", + bodySize: limit + 1, maxAttempts: 5, expectErr: true, expectTooBig: true, expectCalls: 1}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + calls := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + calls++ + w.WriteHeader(http.StatusOK) + _, _ = w.Write(bytes.Repeat([]byte{'x'}, tc.bodySize)) + })) + defer srv.Close() + c := testClient(tc.maxAttempts, nil) + + res, err := c.Get(context.Background(), srv.URL, Conditional{}) + if tc.expectErr && err == nil { + t.Fatalf("expected error, got nil (body len %d)", len(res.Body)) + } + if !tc.expectErr && err != nil { + t.Fatalf("unexpected error: %v", err) + } + if errors.Is(err, ErrBodyTooLarge) != tc.expectTooBig { + t.Errorf("errors.Is(err, ErrBodyTooLarge) = %v, want %v (err=%v)", !tc.expectTooBig, tc.expectTooBig, err) + } + if !tc.expectErr && len(res.Body) != tc.expectBodyLen { + t.Errorf("body len = %d, want %d", len(res.Body), tc.expectBodyLen) + } + if tc.expectErr && res.Body != nil { + t.Errorf("body should not be retained on error, got %d bytes", len(res.Body)) + } + if calls != tc.expectCalls { + t.Errorf("server calls = %d, want %d", calls, tc.expectCalls) + } + }) + } +} + // TestGetContextCancelDuringBackoff verifies that a canceled context during // the backoff wait aborts with the context error rather than retrying. func TestGetContextCancelDuringBackoff(t *testing.T) { diff --git a/internal/ipfeed/health/health.go b/internal/ipfeed/health/health.go index 5fb40de..797c7b4 100644 --- a/internal/ipfeed/health/health.go +++ b/internal/ipfeed/health/health.go @@ -17,24 +17,32 @@ import ( // Server wraps an http.Server plus a readiness flag. type Server struct { ready atomic.Bool + mux *http.ServeMux http *http.Server } // NewServer builds a health server bound to addr (e.g. ":8080"). It does not // start listening until Start is called. func NewServer(addr string) *Server { - s := &Server{} - mux := http.NewServeMux() - mux.HandleFunc("/healthz", s.handleHealthz) - mux.HandleFunc("/readyz", s.handleReadyz) + s := &Server{mux: http.NewServeMux()} + s.mux.HandleFunc("/healthz", s.handleHealthz) + s.mux.HandleFunc("/readyz", s.handleReadyz) s.http = &http.Server{ Addr: addr, - Handler: mux, + Handler: s.mux, ReadHeaderTimeout: 5 * time.Second, } return s } +// Handle registers an extra handler on the health server's mux (e.g. a +// Prometheus /metrics endpoint), so the daemon exposes one port for +// orchestration probes and scraping. Call before Start; the mux panics on a +// duplicate pattern, exactly like http.ServeMux. +func (s *Server) Handle(pattern string, h http.Handler) { + s.mux.Handle(pattern, h) +} + // SetReady marks the service ready (idempotent). Called after a successful cycle. func (s *Server) SetReady() { s.ready.Store(true) } diff --git a/internal/ipfeed/health/health_test.go b/internal/ipfeed/health/health_test.go index 0e8dfe4..279ad9c 100644 --- a/internal/ipfeed/health/health_test.go +++ b/internal/ipfeed/health/health_test.go @@ -40,6 +40,68 @@ func TestReadyzHealthz(t *testing.T) { } } +// TestHandle covers mounting an extra handler (the daemon's Prometheus +// /metrics) next to the probes: it is served, the probes keep working, an +// unregistered path still 404s, and a duplicate pattern panics like +// http.ServeMux does. +// +// go test ./internal/ipfeed/health/ -run TestHandle +func TestHandle(t *testing.T) { + metricsBody := "xtcp_gauges{function=\"loadAsn\"} 3\n" + metrics := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(metricsBody)) + }) + tests := []struct { + description string + register []string // patterns to Handle with the metrics handler, in order + path string + wantStatus int + wantBody string // "" = not checked + wantPanic bool + }{ + // positive + {"registered /metrics is served with the handler's body", []string{"/metrics"}, "/metrics", http.StatusOK, metricsBody, false}, + {"probes keep working alongside /metrics", []string{"/metrics"}, "/healthz", http.StatusOK, "ok", false}, + // negative + {"nothing registered: /metrics 404s", nil, "/metrics", http.StatusNotFound, "", false}, + {"an unrelated path still 404s", []string{"/metrics"}, "/nope", http.StatusNotFound, "", false}, + // corner + {"registering the same pattern twice panics (ServeMux contract)", []string{"/metrics", "/metrics"}, "/metrics", 0, "", true}, + {"registering a probe path again panics rather than silently replacing it", []string{"/healthz"}, "/healthz", 0, "", true}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + s := NewServer(":0") + panicked := func() (p bool) { + defer func() { + if r := recover(); r != nil { + p = true + } + }() + for _, pat := range tc.register { + s.Handle(pat, metrics) + } + return false + }() + if panicked != tc.wantPanic { + t.Fatalf("panicked = %v, want %v", panicked, tc.wantPanic) + } + if tc.wantPanic { + return + } + rec := httptest.NewRecorder() + s.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, tc.path, nil)) + if rec.Code != tc.wantStatus { + t.Errorf("GET %s status = %d, want %d", tc.path, rec.Code, tc.wantStatus) + } + if tc.wantBody != "" && rec.Body.String() != tc.wantBody { + t.Errorf("GET %s body = %q, want %q", tc.path, rec.Body.String(), tc.wantBody) + } + }) + } +} + func TestSetReadyIdempotent(t *testing.T) { s := NewServer(":0") if s.Ready() { diff --git a/internal/ipfeed/output/parquet.go b/internal/ipfeed/output/parquet.go index f87dd7c..f1ac187 100644 --- a/internal/ipfeed/output/parquet.go +++ b/internal/ipfeed/output/parquet.go @@ -2,6 +2,7 @@ package output import ( + "errors" "fmt" "os" "time" @@ -18,11 +19,32 @@ func Timestamp(t time.Time) string { return t.UTC().Format("2006-01-02-15-04") } func Filename(t time.Time) string { return Timestamp(t) + ".parquet" } // WriteParquet writes records to path and returns the file size in bytes. -func WriteParquet(path string, records []model.Record) (int64, error) { - f, err := os.Create(path) +// +// The write is atomic with respect to readers of path: rows go to a temporary +// file in the same directory (path + ".tmp"), which is fsync'ed, closed and +// then renamed over path. A consumer such as xtcp2's pkg/ipasn that reloads the +// artifact on a timer therefore only ever opens a complete file — never a +// half-written one — and a crash mid-write leaves the previous artifact in +// place. On any error the temporary file is removed. +func WriteParquet(path string, records []model.Record) (n int64, err error) { + tmp := path + ".tmp" + f, err := os.Create(tmp) if err != nil { return 0, err } + // Until the rename succeeds, every failure path discards the temp file. A + // failure to remove it is folded into the returned error so a stale .tmp + // never goes unnoticed (the next run overwrites it anyway). + committed := false + defer func() { + if committed { + return + } + if rerr := os.Remove(tmp); rerr != nil && !errors.Is(rerr, os.ErrNotExist) { + err = errors.Join(err, fmt.Errorf("remove %s: %w", tmp, rerr)) + } + }() + w := parquet.NewGenericWriter[model.Record](f) if len(records) > 0 { if _, err := w.Write(records); err != nil { @@ -34,6 +56,10 @@ func WriteParquet(path string, records []model.Record) (int64, error) { _ = f.Close() // error path: best-effort close, surfacing the writer error return 0, fmt.Errorf("close parquet writer: %w", err) } + if err := f.Sync(); err != nil { + _ = f.Close() // error path: best-effort close, surfacing the sync error + return 0, fmt.Errorf("sync parquet file: %w", err) + } fi, err := f.Stat() if err != nil { _ = f.Close() // error path: best-effort close, surfacing the stat error @@ -43,5 +69,9 @@ func WriteParquet(path string, records []model.Record) (int64, error) { if err := f.Close(); err != nil { return 0, err } + if err := os.Rename(tmp, path); err != nil { + return 0, fmt.Errorf("rename parquet file into place: %w", err) + } + committed = true return size, nil } diff --git a/internal/ipfeed/output/parquet_test.go b/internal/ipfeed/output/parquet_test.go index 17c0e40..d0d9683 100644 --- a/internal/ipfeed/output/parquet_test.go +++ b/internal/ipfeed/output/parquet_test.go @@ -69,6 +69,93 @@ func TestWriteParquet(t *testing.T) { if got := pf.NumRows(); got != int64(len(tc.records)) { t.Errorf("%s: NumRows = %d, want %d", tc.desc, got, len(tc.records)) } + if _, err := os.Stat(path + ".tmp"); !os.IsNotExist(err) { + t.Errorf("%s: temp file %s.tmp left behind (stat err=%v)", tc.desc, path, err) + } + }) + } +} + +// TestWriteParquetAtomic covers the temp-file + rename contract: the target is +// either the previous complete artifact or the new complete artifact, and no +// temp file survives either outcome. +func TestWriteParquetAtomic(t *testing.T) { + two := []model.Record{{Prefix: "1.2.3.0/24", IPVersion: 4}, {Prefix: "2600::/16", IPVersion: 6}} + five := []model.Record{ + {Prefix: "10.0.0.0/8", IPVersion: 4}, {Prefix: "10.1.0.0/16", IPVersion: 4}, {Prefix: "10.2.0.0/16", IPVersion: 4}, + {Prefix: "fd00::/8", IPVersion: 6}, {Prefix: "fd01::/16", IPVersion: 6}, + } + + tests := []struct { + description string + setup func(t *testing.T, dir string) string // returns the target path + records []model.Record + wantErr bool + wantRows int64 // rows readable at the target afterwards (-1 = target must not exist) + }{ + // positive + {"fresh path: file created, no temp left", func(t *testing.T, dir string) string { + return filepath.Join(dir, "a.parquet") + }, two, false, 2}, + {"existing artifact is replaced by the new one (rename over)", func(t *testing.T, dir string) string { + p := filepath.Join(dir, "b.parquet") + if _, err := WriteParquet(p, two); err != nil { + t.Fatal(err) + } + return p + }, five, false, 5}, + // corner + {"stale temp file from an earlier crash is overwritten, not an error", func(t *testing.T, dir string) string { + p := filepath.Join(dir, "c.parquet") + if err := os.WriteFile(p+".tmp", []byte("garbage"), 0o600); err != nil { + t.Fatal(err) + } + return p + }, two, false, 2}, + // negative + {"missing directory: error, nothing created", func(t *testing.T, dir string) string { + return filepath.Join(dir, "missing", "d.parquet") + }, two, true, -1}, + {"target path is a directory: rename fails, temp removed", func(t *testing.T, dir string) string { + p := filepath.Join(dir, "e.parquet") + if err := os.Mkdir(p, 0o755); err != nil { + t.Fatal(err) + } + return p + }, two, true, -1}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + dir := t.TempDir() + path := tc.setup(t, dir) + + _, err := WriteParquet(path, tc.records) + if (err != nil) != tc.wantErr { + t.Fatalf("err = %v, wantErr %v", err, tc.wantErr) + } + if _, serr := os.Stat(path + ".tmp"); !os.IsNotExist(serr) { + t.Errorf("temp file left behind (stat err=%v)", serr) + } + if tc.wantRows < 0 { + if st, serr := os.Stat(path); serr == nil && !st.IsDir() { + t.Errorf("target file exists after a failed write") + } + return + } + f, err := os.Open(path) + if err != nil { + t.Fatal(err) + } + defer f.Close() + st, _ := f.Stat() + pf, err := parquet.OpenFile(f, st.Size()) + if err != nil { + t.Fatalf("reopen: %v", err) + } + if got := pf.NumRows(); got != tc.wantRows { + t.Errorf("NumRows = %d, want %d", got, tc.wantRows) + } }) } } diff --git a/internal/ipfeed/parse/parse_more_test.go b/internal/ipfeed/parse/parse_more_test.go new file mode 100644 index 0000000..f751b1a --- /dev/null +++ b/internal/ipfeed/parse/parse_more_test.go @@ -0,0 +1,590 @@ +package parse + +import ( + "reflect" + "strings" + "testing" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" +) + +// The parsers under test here (azure, atlassian, fastly, m365, oci, salesforce) +// deliberately do no CIDR validation, canonicalisation, or de-duplication: they +// copy the feed's prefix string verbatim and leave rejection to the combine +// stage. The corner rows below pin that pass-through contract so a future +// change to it is a conscious one. + +// parserCase is one table row shared by all six parser tests. expected is the +// full ordered record list (compared field-for-field against the parser's +// output); expectedErr, when non-empty, is a substring the returned error must +// contain and implies no records are checked. +type parserCase struct { + description string + in string + expected []model.Record + expectedErr string +} + +// checkRecords asserts the error expectation and the exact ordered record list. +// A nil and an empty slice are both accepted for "zero records". +func checkRecords(t *testing.T, desc string, got []model.Record, err error, want []model.Record, wantErr string) { + t.Helper() + if wantErr != "" { + if err == nil { + t.Fatalf("%s: expected error containing %q, got nil", desc, wantErr) + } + if !strings.Contains(err.Error(), wantErr) { + t.Fatalf("%s: error %q does not contain %q", desc, err.Error(), wantErr) + } + return + } + if err != nil { + t.Fatalf("%s: unexpected error: %v", desc, err) + } + if len(got) == 0 && len(want) == 0 { + return + } + if len(got) != len(want) { + t.Fatalf("%s: got %d records, want %d\n got: %+v\nwant: %+v", desc, len(got), len(want), got, want) + } + for i := range want { + if !reflect.DeepEqual(got[i], want[i]) { + t.Errorf("%s: record[%d] mismatch\n got: %+v\nwant: %+v", desc, i, got[i], want[i]) + } + } +} + +func runParserCases(t *testing.T, parserName string, meta SourceMeta, tests []parserCase) { + t.Helper() + p, ok := Get(parserName) + if !ok { + t.Fatalf("parser %q is not registered", parserName) + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got, err := p.Parse([]byte(tc.in), meta, ts) + checkRecords(t, tc.description, got, err, tc.expected, tc.expectedErr) + }) + } +} + +// TestAzureServiceTags covers the Azure Service Tags parser: one record per +// addressPrefixes entry, Service = systemService (falling back to the tag +// name), Region = properties.region. +func TestAzureServiceTags(t *testing.T) { + meta := SourceMeta{ + Name: "azure-service-tags", Provider: "azure", + URL: "https://www.microsoft.com/en-us/download/details.aspx?id=56519", + SourceType: "provider_feed", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "microsoft", ServiceOperator: "microsoft"}, + } + mk := func(prefix, service, region string) model.Record { + r := meta.Base(ts) + r.Prefix, r.Service, r.Region = prefix, service, region + return r + } + tests := []parserCase{ + // positive + { + description: "positive: realistic tag with v4+v6 prefixes yields one record per prefix with systemService and region", + in: `{"changeNumber":363,"cloud":"Public","values":[{"name":"ActionGroup","id":"ActionGroup", + "properties":{"changeNumber":52,"region":"","regionId":0,"platform":"Azure","systemService":"ActionGroup", + "addressPrefixes":["4.145.74.52/30","2603:1000:4::140/123"],"networkFeatures":["API","NSG","UDR","FW"]}}, + {"name":"AzureCloud.eastus","id":"AzureCloud.eastus", + "properties":{"region":"eastus","platform":"Azure","systemService":"AzureCloud", + "addressPrefixes":["13.68.128.0/17"]}}]}`, + expected: []model.Record{ + mk("4.145.74.52/30", "ActionGroup", ""), + mk("2603:1000:4::140/123", "ActionGroup", ""), + mk("13.68.128.0/17", "AzureCloud", "eastus"), + }, + }, + { + description: "positive: empty systemService falls back to the tag name", + in: `{"values":[{"name":"ApiManagement.WestUS","properties":{"region":"westus","systemService":"","addressPrefixes":["13.64.39.16/32"]}}]}`, + expected: []model.Record{mk("13.64.39.16/32", "ApiManagement.WestUS", "westus")}, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `{"values":[`, + expectedErr: "azure_service_tags:", + }, + { + description: "negative: top-level array instead of object errors", + in: `[{"name":"x"}]`, + expectedErr: "azure_service_tags:", + }, + { + description: "negative: addressPrefixes as a scalar instead of an array errors", + in: `{"values":[{"name":"x","properties":{"addressPrefixes":"1.2.3.0/24"}}]}`, + expectedErr: "azure_service_tags:", + }, + // boundary + { + description: "boundary: empty values array yields zero records", + in: `{"changeNumber":1,"cloud":"Public","values":[]}`, + expected: nil, + }, + { + description: "boundary: a tag with an empty addressPrefixes array contributes no records", + in: `{"values":[{"name":"Empty","properties":{"systemService":"Empty","addressPrefixes":[]}},{"name":"B","properties":{"systemService":"B","addressPrefixes":["10.0.0.0/8"]}}]}`, + expected: []model.Record{mk("10.0.0.0/8", "B", "")}, + }, + { + description: "boundary: JSON null decodes to an empty document and zero records", + in: `null`, + expected: nil, + }, + { + description: "boundary: a prefix without a mask is passed through verbatim for combine to judge", + in: `{"values":[{"name":"S","properties":{"systemService":"S","addressPrefixes":["20.1.2.3"]}}]}`, + expected: []model.Record{mk("20.1.2.3", "S", "")}, + }, + // corner + { + description: "corner: duplicate prefixes within and across tags are all retained (no dedup)", + in: `{"values":[{"name":"A","properties":{"systemService":"A","addressPrefixes":["10.0.0.0/8","10.0.0.0/8"]}},{"name":"B","properties":{"systemService":"B","addressPrefixes":["10.0.0.0/8"]}}]}`, + expected: []model.Record{ + mk("10.0.0.0/8", "A", ""), mk("10.0.0.0/8", "A", ""), mk("10.0.0.0/8", "B", ""), + }, + }, + { + description: "corner: whitespace and host bits are not canonicalised", + in: `{"values":[{"name":"A","properties":{"systemService":"A","addressPrefixes":[" 10.0.0.1/8 "]}}]}`, + expected: []model.Record{mk(" 10.0.0.1/8 ", "A", "")}, + }, + { + description: "corner: unknown fields at every level are ignored", + in: `{"extra":1,"values":[{"name":"A","bogus":true,"properties":{"systemService":"A","addressPrefixes":["10.0.0.0/8"],"networkFeatures":["API"]}}]}`, + expected: []model.Record{mk("10.0.0.0/8", "A", "")}, + }, + } + runParserCases(t, "azure_service_tags", meta, tests) +} + +// TestAtlassian covers the Atlassian parser: one record per item, with the +// product/region/direction arrays comma-joined and creationDate stamped as +// SourceTimestamp. +func TestAtlassian(t *testing.T) { + meta := SourceMeta{ + Name: "atlassian", Provider: "atlassian", URL: "https://ip-ranges.atlassian.com/", + SourceType: "provider_feed", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "atlassian", ServiceOperator: "atlassian"}, + } + mk := func(prefix, product, region, direction, sourceTS string) model.Record { + r := meta.Base(ts) + r.Prefix, r.Product, r.Region, r.Direction, r.SourceTimestamp = prefix, product, region, direction, sourceTS + return r + } + const created = "2026-01-01T00:00:00.000000Z" + tests := []parserCase{ + // positive + { + description: "positive: realistic items with multi-valued product/region/direction are comma-joined and creationDate stamped", + in: `{"creationDate":"` + created + `","syncToken":1735689600,"items":[ + {"network":"3.26.128.128","mask_len":26,"cidr":"3.26.128.128/26","mask":"255.255.255.192", + "region":["ap-southeast-2"],"product":["jira","confluence"],"direction":["egress"],"perimeter":"commercial"}, + {"network":"2401:1d80:3000::","mask_len":36,"cidr":"2401:1d80:3000::/36", + "region":["global","us-east-1"],"product":["bitbucket"],"direction":["ingress","egress"]}]}`, + expected: []model.Record{ + mk("3.26.128.128/26", "jira,confluence", "ap-southeast-2", "egress", created), + mk("2401:1d80:3000::/36", "bitbucket", "global,us-east-1", "ingress,egress", created), + }, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `{"items":[{`, + expectedErr: "atlassian:", + }, + { + description: "negative: top-level array instead of object errors", + in: `[]`, + expectedErr: "atlassian:", + }, + { + description: "negative: product as a scalar instead of an array errors", + in: `{"items":[{"cidr":"1.0.0.0/24","product":"jira"}]}`, + expectedErr: "atlassian:", + }, + // boundary + { + description: "boundary: empty items array yields zero records", + in: `{"creationDate":"` + created + `","items":[]}`, + expected: nil, + }, + { + description: "boundary: missing creationDate leaves SourceTimestamp empty", + in: `{"items":[{"cidr":"1.0.0.0/24","region":["r"],"product":["p"],"direction":["egress"]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "p", "r", "egress", "")}, + }, + { + description: "boundary: item with no metadata arrays yields empty joined fields", + in: `{"items":[{"cidr":"1.0.0.0/24"}]}`, + expected: []model.Record{mk("1.0.0.0/24", "", "", "", "")}, + }, + { + description: "boundary: a bare address without a mask is passed through verbatim", + in: `{"items":[{"cidr":"1.2.3.4"}]}`, + expected: []model.Record{mk("1.2.3.4", "", "", "", "")}, + }, + // corner + { + description: "corner: duplicate items are retained in feed order", + in: `{"items":[{"cidr":"1.0.0.0/24","product":["jira"]},{"cidr":"1.0.0.0/24","product":["jira"]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "jira", "", "", ""), mk("1.0.0.0/24", "jira", "", "", "")}, + }, + { + description: "corner: an item with an empty cidr still produces a record (combine rejects it)", + in: `{"items":[{"product":["jira"]}]}`, + expected: []model.Record{mk("", "jira", "", "", "")}, + }, + { + description: "corner: unknown fields are ignored", + in: `{"foo":"bar","items":[{"cidr":"1.0.0.0/24","perimeter":"commercial","nested":{"x":1}}]}`, + expected: []model.Record{mk("1.0.0.0/24", "", "", "", "")}, + }, + } + runParserCases(t, "atlassian", meta, tests) +} + +// TestFastly covers the Fastly public-ip-list parser: addresses then +// ipv6_addresses, one record each, with no per-record metadata. +func TestFastly(t *testing.T) { + meta := SourceMeta{ + Name: "fastly", Provider: "fastly", URL: "https://api.fastly.com/public-ip-list", + SourceType: "provider_api", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "fastly", ServiceOperator: "fastly"}, + } + mk := func(prefix string) model.Record { + r := meta.Base(ts) + r.Prefix = prefix + return r + } + tests := []parserCase{ + // positive + { + description: "positive: v4 addresses come first, then v6, each as a bare record", + in: `{"addresses":["23.235.32.0/20","43.249.72.0/22"],"ipv6_addresses":["2a04:4e40::/32","2a04:4e42::/32"]}`, + expected: []model.Record{ + mk("23.235.32.0/20"), mk("43.249.72.0/22"), mk("2a04:4e40::/32"), mk("2a04:4e42::/32"), + }, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `{"addresses":["1.0.0.0/24"`, + expectedErr: "fastly:", + }, + { + description: "negative: top-level array instead of object errors", + in: `["1.0.0.0/24"]`, + expectedErr: "fastly:", + }, + { + description: "negative: a non-string element in addresses errors", + in: `{"addresses":[1]}`, + expectedErr: "fastly:", + }, + // boundary + { + description: "boundary: both arrays empty yields zero records", + in: `{"addresses":[],"ipv6_addresses":[]}`, + expected: nil, + }, + { + description: "boundary: empty object yields zero records", + in: `{}`, + expected: nil, + }, + { + description: "boundary: only v6 present", + in: `{"ipv6_addresses":["2a04:4e40::/32"]}`, + expected: []model.Record{mk("2a04:4e40::/32")}, + }, + { + description: "boundary: a host address without a mask is passed through verbatim", + in: `{"addresses":["23.235.32.1"]}`, + expected: []model.Record{mk("23.235.32.1")}, + }, + // corner + { + description: "corner: duplicates across the two arrays are retained", + in: `{"addresses":["1.0.0.0/24","1.0.0.0/24"],"ipv6_addresses":["1.0.0.0/24"]}`, + expected: []model.Record{mk("1.0.0.0/24"), mk("1.0.0.0/24"), mk("1.0.0.0/24")}, + }, + { + description: "corner: a v6 prefix listed under addresses is not re-sorted; order is v4 array then v6 array", + in: `{"addresses":["2a04::/32"],"ipv6_addresses":["1.0.0.0/24"]}`, + expected: []model.Record{mk("2a04::/32"), mk("1.0.0.0/24")}, + }, + { + description: "corner: unknown fields are ignored", + in: `{"addresses":["1.0.0.0/24"],"version":2,"meta":{"a":1}}`, + expected: []model.Record{mk("1.0.0.0/24")}, + }, + } + runParserCases(t, "fastly", meta, tests) +} + +// TestM365 covers the Microsoft 365 endpoints parser: a top-level array of +// endpoint sets, one record per ips entry, Service = serviceArea and Product = +// category (which overrides the source default product). +func TestM365(t *testing.T) { + meta := SourceMeta{ + Name: "m365-worldwide", Provider: "microsoft", + URL: "https://endpoints.office.com/endpoints/worldwide?clientrequestid=00000000-0000-0000-0000-000000000000", + SourceType: "provider_api", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "microsoft", ServiceOperator: "microsoft", Product: "microsoft-365"}, + } + mk := func(prefix, service, product string) model.Record { + r := meta.Base(ts) + r.Prefix, r.Service, r.Product = prefix, service, product + return r + } + tests := []parserCase{ + // positive + { + description: "positive: realistic endpoint sets yield one record per ip with serviceArea and category", + in: `[{"id":1,"serviceArea":"Exchange","serviceAreaDisplayName":"Exchange Online","urls":["outlook.office.com"], + "ips":["13.107.6.152/31","2603:1006::/40"],"tcpPorts":"80,443","expressRoute":true,"category":"Optimize","required":true}, + {"id":31,"serviceArea":"Skype","serviceAreaDisplayName":"Skype for Business Online and Microsoft Teams", + "ips":["52.112.0.0/14"],"udpPorts":"3478,3479","category":"Allow","required":true}]`, + expected: []model.Record{ + mk("13.107.6.152/31", "Exchange", "Optimize"), + mk("2603:1006::/40", "Exchange", "Optimize"), + mk("52.112.0.0/14", "Skype", "Allow"), + }, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `[{"serviceArea":"Exchange","ips":[`, + expectedErr: "m365:", + }, + { + description: "negative: top-level object instead of array errors", + in: `{"serviceArea":"Exchange","ips":["1.0.0.0/24"]}`, + expectedErr: "m365:", + }, + { + description: "negative: ips as a scalar instead of an array errors", + in: `[{"serviceArea":"Exchange","ips":"1.0.0.0/24"}]`, + expectedErr: "m365:", + }, + // boundary + { + description: "boundary: empty array yields zero records", + in: `[]`, + expected: nil, + }, + { + description: "boundary: URL-only endpoint sets (no ips key) contribute no records", + in: `[{"id":2,"serviceArea":"Exchange","urls":["*.outlook.com"],"category":"Default"},{"id":3,"serviceArea":"SharePoint","ips":["13.107.136.0/22"],"category":"Optimize"}]`, + expected: []model.Record{mk("13.107.136.0/22", "SharePoint", "Optimize")}, + }, + { + description: "boundary: an endpoint set with an empty ips array contributes no records", + in: `[{"serviceArea":"Exchange","ips":[],"category":"Default"}]`, + expected: nil, + }, + { + description: "boundary: a host address without a mask is passed through verbatim", + in: `[{"serviceArea":"Exchange","ips":["13.107.6.152"],"category":"Optimize"}]`, + expected: []model.Record{mk("13.107.6.152", "Exchange", "Optimize")}, + }, + // corner + { + description: "corner: a missing category clears the source default product rather than keeping it", + in: `[{"serviceArea":"Exchange","ips":["13.107.6.152/31"]}]`, + expected: []model.Record{mk("13.107.6.152/31", "Exchange", "")}, + }, + { + description: "corner: duplicate ips across endpoint sets are retained", + in: `[{"serviceArea":"Exchange","ips":["1.0.0.0/24"],"category":"Optimize"},{"serviceArea":"Skype","ips":["1.0.0.0/24"],"category":"Allow"}]`, + expected: []model.Record{mk("1.0.0.0/24", "Exchange", "Optimize"), mk("1.0.0.0/24", "Skype", "Allow")}, + }, + { + description: "corner: unknown fields (ports, urls, notes) are ignored", + in: `[{"id":9,"serviceArea":"Common","ips":["1.0.0.0/24"],"tcpPorts":"443","urls":["a.b"],"notes":"x","category":"Allow","extra":{"k":1}}]`, + expected: []model.Record{mk("1.0.0.0/24", "Common", "Allow")}, + }, + } + runParserCases(t, "m365", meta, tests) +} + +// TestOCI covers the Oracle Cloud parser: regions -> cidrs, one record per +// cidr, Region from the group, Service = comma-joined tags, and +// last_updated_timestamp stamped as SourceTimestamp. +func TestOCI(t *testing.T) { + meta := SourceMeta{ + Name: "oci", Provider: "oracle", URL: "https://docs.oracle.com/iaas/tools/public_ip_ranges.json", + SourceType: "provider_feed", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "oracle", ServiceOperator: "oracle"}, + } + mk := func(prefix, region, service, sourceTS string) model.Record { + r := meta.Base(ts) + r.Prefix, r.Region, r.Service, r.SourceTimestamp = prefix, region, service, sourceTS + return r + } + const updated = "2026-01-01T00:00:00.000000" + tests := []parserCase{ + // positive + { + description: "positive: realistic regions with tagged cidrs yield per-cidr records with region, joined tags, and timestamp", + in: `{"last_updated_timestamp":"` + updated + `","regions":[ + {"region":"us-phoenix-1","cidrs":[{"cidr":"129.146.0.0/21","tags":["OCI"]},{"cidr":"129.146.8.0/22","tags":["OSN","OBJECT_STORAGE"]}]}, + {"region":"eu-frankfurt-1","cidrs":[{"cidr":"2603:c020:0:8000::/50","tags":["OCI"]}]}]}`, + expected: []model.Record{ + mk("129.146.0.0/21", "us-phoenix-1", "OCI", updated), + mk("129.146.8.0/22", "us-phoenix-1", "OSN,OBJECT_STORAGE", updated), + mk("2603:c020:0:8000::/50", "eu-frankfurt-1", "OCI", updated), + }, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `{"regions":[{"region":"x","cidrs":[`, + expectedErr: "oci:", + }, + { + description: "negative: top-level array instead of object errors", + in: `[{"region":"x"}]`, + expectedErr: "oci:", + }, + { + description: "negative: cidrs as an array of strings (not objects) errors", + in: `{"regions":[{"region":"x","cidrs":["1.0.0.0/24"]}]}`, + expectedErr: "oci:", + }, + // boundary + { + description: "boundary: empty regions array yields zero records", + in: `{"last_updated_timestamp":"` + updated + `","regions":[]}`, + expected: nil, + }, + { + description: "boundary: a region with an empty cidrs array contributes no records", + in: `{"regions":[{"region":"empty","cidrs":[]},{"region":"r","cidrs":[{"cidr":"1.0.0.0/24","tags":["OCI"]}]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "OCI", "")}, + }, + { + description: "boundary: a cidr with no tags yields an empty service", + in: `{"regions":[{"region":"r","cidrs":[{"cidr":"1.0.0.0/24"}]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "", "")}, + }, + { + description: "boundary: a bare address without a mask is passed through verbatim", + in: `{"regions":[{"region":"r","cidrs":[{"cidr":"129.146.0.1","tags":["OCI"]}]}]}`, + expected: []model.Record{mk("129.146.0.1", "r", "OCI", "")}, + }, + // corner + { + description: "corner: the same cidr in two regions yields two records (no dedup)", + in: `{"regions":[{"region":"a","cidrs":[{"cidr":"1.0.0.0/24","tags":["OCI"]}]},{"region":"b","cidrs":[{"cidr":"1.0.0.0/24","tags":["OCI"]}]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "a", "OCI", ""), mk("1.0.0.0/24", "b", "OCI", "")}, + }, + { + description: "corner: tag order is preserved in the joined service string", + in: `{"regions":[{"region":"r","cidrs":[{"cidr":"1.0.0.0/24","tags":["OSN","OCI","OBJECT_STORAGE"]}]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "OSN,OCI,OBJECT_STORAGE", "")}, + }, + { + description: "corner: unknown fields are ignored", + in: `{"extra":true,"regions":[{"region":"r","key":"k","cidrs":[{"cidr":"1.0.0.0/24","tags":["OCI"],"note":"n"}]}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "OCI", "")}, + }, + } + runParserCases(t, "oci", meta, tests) +} + +// TestSalesforce covers the Salesforce (Hyperforce) parser: AWS-style +// prefixes / ipv6_prefixes with region and direction, createDate stamped as +// SourceTimestamp, and the source default Service left untouched. +func TestSalesforce(t *testing.T) { + meta := SourceMeta{ + Name: "salesforce", Provider: "salesforce", URL: "https://ip-ranges.salesforce.com/ip-ranges.json", + SourceType: "provider_feed", Confidence: "authoritative", + Defaults: Defaults{NetworkOwner: "salesforce", ServiceOperator: "salesforce", Service: "hyperforce"}, + } + mk := func(prefix, region, direction, sourceTS string) model.Record { + r := meta.Base(ts) + r.Prefix, r.Region, r.Direction, r.SourceTimestamp = prefix, region, direction, sourceTS + return r + } + const created = "2026-01-01-00-00-00" + tests := []parserCase{ + // positive + { + description: "positive: v4 then v6 prefixes with region/direction; default service hyperforce is retained", + in: `{"syncToken":"1735689600","createDate":"` + created + `", + "prefixes":[{"ip_prefix":"13.108.0.0/14","region":"GLOBAL","direction":"inbound"},{"ip_prefix":"96.43.144.0/20","region":"us-east-1","direction":"outbound"}], + "ipv6_prefixes":[{"ipv6_prefix":"2600:1f14:4f7:2000::/56","region":"us-west-2","direction":"outbound"}]}`, + expected: []model.Record{ + mk("13.108.0.0/14", "GLOBAL", "inbound", created), + mk("96.43.144.0/20", "us-east-1", "outbound", created), + mk("2600:1f14:4f7:2000::/56", "us-west-2", "outbound", created), + }, + }, + // negative + { + description: "negative: malformed JSON errors with the parser prefix", + in: `{"prefixes":[{"ip_prefix":`, + expectedErr: "salesforce:", + }, + { + description: "negative: top-level array instead of object errors", + in: `[]`, + expectedErr: "salesforce:", + }, + { + description: "negative: prefixes as an array of strings (not objects) errors", + in: `{"prefixes":["1.0.0.0/24"]}`, + expectedErr: "salesforce:", + }, + // boundary + { + description: "boundary: both arrays empty yields zero records", + in: `{"createDate":"` + created + `","prefixes":[],"ipv6_prefixes":[]}`, + expected: nil, + }, + { + description: "boundary: empty object yields zero records", + in: `{}`, + expected: nil, + }, + { + description: "boundary: only v6 present, missing createDate leaves SourceTimestamp empty", + in: `{"ipv6_prefixes":[{"ipv6_prefix":"2600::/16","region":"r","direction":"inbound"}]}`, + expected: []model.Record{mk("2600::/16", "r", "inbound", "")}, + }, + { + description: "boundary: an entry missing region and direction yields empty fields", + in: `{"prefixes":[{"ip_prefix":"1.0.0.0/24"}]}`, + expected: []model.Record{mk("1.0.0.0/24", "", "", "")}, + }, + { + description: "boundary: a host address without a mask is passed through verbatim", + in: `{"prefixes":[{"ip_prefix":"13.108.0.1","region":"GLOBAL","direction":"inbound"}]}`, + expected: []model.Record{mk("13.108.0.1", "GLOBAL", "inbound", "")}, + }, + // corner + { + description: "corner: the same prefix listed inbound and outbound yields two records", + in: `{"prefixes":[{"ip_prefix":"1.0.0.0/24","region":"r","direction":"inbound"},{"ip_prefix":"1.0.0.0/24","region":"r","direction":"outbound"}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "inbound", ""), mk("1.0.0.0/24", "r", "outbound", "")}, + }, + { + description: "corner: an ipv6_prefixes entry using the v4 key name yields an empty prefix (not cross-read)", + in: `{"ipv6_prefixes":[{"ip_prefix":"2600::/16","region":"r","direction":"inbound"}]}`, + expected: []model.Record{mk("", "r", "inbound", "")}, + }, + { + description: "corner: unknown fields (syncToken, service, network_border_group) are ignored", + in: `{"syncToken":"x","prefixes":[{"ip_prefix":"1.0.0.0/24","region":"r","direction":"inbound","service":"S","network_border_group":"g"}]}`, + expected: []model.Record{mk("1.0.0.0/24", "r", "inbound", "")}, + }, + } + runParserCases(t, "salesforce", meta, tests) +} diff --git a/internal/ipfeed/s3/uploader.go b/internal/ipfeed/s3/uploader.go index daec218..49e4698 100644 --- a/internal/ipfeed/s3/uploader.go +++ b/internal/ipfeed/s3/uploader.go @@ -44,17 +44,7 @@ func New(ctx context.Context, cfg Config) (Uploader, error) { if cfg.Bucket == "" { return nil, fmt.Errorf("s3: bucket is required") } - endpoint := cfg.Endpoint - secure := true - switch { - case strings.HasPrefix(endpoint, "https://"): - endpoint = strings.TrimPrefix(endpoint, "https://") - secure = true - case strings.HasPrefix(endpoint, "http://"): - endpoint = strings.TrimPrefix(endpoint, "http://") - secure = false - } - endpoint = strings.TrimSuffix(endpoint, "/") + endpoint, secure := parseEndpoint(cfg.Endpoint) region := cfg.Region if region == "" { region = "us-east-1" @@ -79,6 +69,27 @@ func New(ctx context.Context, cfg Config) (Uploader, error) { return &minioUploader{client: cl, cfg: cfg}, nil } +// parseEndpoint derives the bare host[:port] minio expects and whether to use +// TLS from a configured endpoint. An explicit "https://" or "http://" scheme +// is stripped and selects TLS on/off respectively; anything else (a bare host, +// or an unrecognised scheme) is passed through verbatim and defaults to TLS. +// A single trailing "/" is removed. No further validation is done here: minio +// reports a malformed host when the client is constructed. +func parseEndpoint(raw string) (host string, secure bool) { + host = raw + secure = true + switch { + case strings.HasPrefix(host, "https://"): + host = strings.TrimPrefix(host, "https://") + secure = true + case strings.HasPrefix(host, "http://"): + host = strings.TrimPrefix(host, "http://") + secure = false + } + host = strings.TrimSuffix(host, "/") + return host, secure +} + // Key joins the configured prefix with filename, e.g. "prefix/2026-09-09.parquet". func (cfg Config) Key(filename string) string { p := strings.Trim(cfg.Prefix, "/") diff --git a/internal/ipfeed/s3/uploader_test.go b/internal/ipfeed/s3/uploader_test.go index 93a1edd..90058a1 100644 --- a/internal/ipfeed/s3/uploader_test.go +++ b/internal/ipfeed/s3/uploader_test.go @@ -32,6 +32,48 @@ func TestConfigKey(t *testing.T) { } } +// TestParseEndpoint covers scheme stripping, TLS selection, and trailing-slash +// trimming. Path-style vs virtual-host addressing is not a concept here (minio +// decides that from the host), so it is not tested. +func TestParseEndpoint(t *testing.T) { + tests := []struct { + description string + in string + expectedHost string + expectedSecure bool + }{ + // positive + {"positive: https URL is stripped to host and selects TLS", "https://s3.amazonaws.com", "s3.amazonaws.com", true}, + {"positive: http URL is stripped to host and disables TLS", "http://minio.local:9000", "minio.local:9000", false}, + {"positive: bare host:port without scheme is passed through and defaults to TLS", "minio.local:9000", "minio.local:9000", true}, + {"positive: bare hostname without port or scheme defaults to TLS", "s3.us-east-1.amazonaws.com", "s3.us-east-1.amazonaws.com", true}, + // negative + {"negative: an unrecognised scheme is not stripped and defaults to TLS (minio rejects it later)", "ftp://host:21", "ftp://host:21", true}, + {"negative: a malformed URL is passed through verbatim", "ht!tp://bad host", "ht!tp://bad host", true}, + // boundary + {"boundary: empty string yields empty host with TLS default", "", "", true}, + {"boundary: a scheme with no host yields empty host", "https://", "", true}, + {"boundary: a lone slash is trimmed to empty", "/", "", true}, + // corner + {"corner: trailing slash on https URL is trimmed", "https://s3.amazonaws.com/", "s3.amazonaws.com", true}, + {"corner: trailing slash on bare host:port is trimmed", "minio.local:9000/", "minio.local:9000", true}, + {"corner: only one trailing slash is trimmed", "http://host//", "host/", false}, + {"corner: a path component is kept after the host", "https://host:9000/bucket/", "host:9000/bucket", true}, + {"corner: uppercase scheme is not recognised and is kept verbatim", "HTTPS://host", "HTTPS://host", true}, + {"corner: an IPv4 literal with port and http scheme", "http://127.0.0.1:9000/", "127.0.0.1:9000", false}, + {"corner: a bracketed IPv6 literal with port and https scheme", "https://[::1]:9000", "[::1]:9000", true}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + host, secure := parseEndpoint(tc.in) + if host != tc.expectedHost || secure != tc.expectedSecure { + t.Errorf("%s: parseEndpoint(%q) = (%q, %v), want (%q, %v)", + tc.description, tc.in, host, secure, tc.expectedHost, tc.expectedSecure) + } + }) + } +} + func TestSecretFromFile(t *testing.T) { dir := t.TempDir() good := filepath.Join(dir, "secret") diff --git a/internal/ipfeed/summary/summary_test.go b/internal/ipfeed/summary/summary_test.go new file mode 100644 index 0000000..b580b76 --- /dev/null +++ b/internal/ipfeed/summary/summary_test.go @@ -0,0 +1,260 @@ +package summary + +import ( + "bytes" + "errors" + "strings" + "testing" + "time" +) + +// TestSummaryCounts covers Add plus the four aggregate accessors across empty, +// single, multi-source, and zero-record inputs. +func TestSummaryCounts(t *testing.T) { + tests := []struct { + description string + sources []SourceResult + expectedLen int + expectedOK int + expectedFail int + expectedValid int + expectedRejected int + }{ + // positive + { + description: "positive: a single successful source is counted once with its record boundaries", + sources: []SourceResult{{Name: "a", OK: true, Parsed: 10, Valid: 8, Rejected: 2}}, + expectedLen: 1, + expectedOK: 1, + expectedValid: 8, expectedRejected: 2, + }, + { + description: "positive: multiple sources sum valid/rejected and split ok/fail", + sources: []SourceResult{ + {Name: "a", OK: true, Valid: 100, Rejected: 1}, + {Name: "b", OK: false, Note: "timeout"}, + {Name: "c", OK: true, Valid: 50, Rejected: 5}, + }, + expectedLen: 3, expectedOK: 2, expectedFail: 1, + expectedValid: 150, expectedRejected: 6, + }, + // negative + { + description: "negative: a single failed source counts as fail with zero records", + sources: []SourceResult{{Name: "a", OK: false, HTTPStatus: 503, Note: "boom"}}, + expectedLen: 1, + expectedFail: 1, + }, + // boundary + { + description: "boundary: no sources yields all-zero totals", + sources: nil, + }, + { + description: "boundary: an ok source with zero records contributes to ok but not to record totals", + sources: []SourceResult{{Name: "empty", OK: true}}, + expectedLen: 1, expectedOK: 1, + }, + // corner + { + description: "corner: a failed source that still reports records is summed into totals", + sources: []SourceResult{{Name: "partial", OK: false, Parsed: 3, Valid: 2, Rejected: 1}}, + expectedLen: 1, expectedFail: 1, + expectedValid: 2, expectedRejected: 1, + }, + { + description: "corner: duplicate source names are not merged", + sources: []SourceResult{ + {Name: "dup", OK: true, Valid: 1}, + {Name: "dup", OK: true, Valid: 1}, + }, + expectedLen: 2, expectedOK: 2, expectedValid: 2, + }, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var s Summary + for _, r := range tc.sources { + s.Add(r) + } + if got := len(s.Sources); got != tc.expectedLen { + t.Errorf("%s: len(Sources) = %d, want %d", tc.description, got, tc.expectedLen) + } + if got := s.OKCount(); got != tc.expectedOK { + t.Errorf("%s: OKCount = %d, want %d", tc.description, got, tc.expectedOK) + } + if got := s.FailCount(); got != tc.expectedFail { + t.Errorf("%s: FailCount = %d, want %d", tc.description, got, tc.expectedFail) + } + if got := s.TotalValid(); got != tc.expectedValid { + t.Errorf("%s: TotalValid = %d, want %d", tc.description, got, tc.expectedValid) + } + if got := s.TotalRejected(); got != tc.expectedRejected { + t.Errorf("%s: TotalRejected = %d, want %d", tc.description, got, tc.expectedRejected) + } + }) + } +} + +// TestHumanBytes covers the byte formatter at each unit boundary. +func TestHumanBytes(t *testing.T) { + tests := []struct { + description string + in int64 + expected string + }{ + // positive + {"positive: small byte count is printed as-is", 512, "512 B"}, + {"positive: 1.5 KiB rounds to one decimal", 1536, "1.5 KB"}, + {"positive: whole MiB", 1 << 20, "1.0 MB"}, + {"positive: whole GiB", 1 << 30, "1.0 GB"}, + {"positive: whole TiB", 1 << 40, "1.0 TB"}, + // boundary + {"boundary: zero bytes", 0, "0 B"}, + {"boundary: one below the KiB threshold stays in bytes", 1023, "1023 B"}, + {"boundary: exactly one KiB switches unit", 1024, "1.0 KB"}, + {"boundary: one below the MiB threshold stays in KB", (1 << 20) - 1, "1024.0 KB"}, + // corner + {"corner: non-integral MiB keeps one decimal", 5*(1<<20) + 3*(1<<18), "5.8 MB"}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if got := humanBytes(tc.in); got != tc.expected { + t.Errorf("%s: humanBytes(%d) = %q, want %q", tc.description, tc.in, got, tc.expected) + } + }) + } +} + +// failingWriter always errors, to exercise the tabwriter flush error path. +type failingWriter struct{} + +func (failingWriter) Write([]byte) (int, error) { return 0, errors.New("sink closed") } + +// normalizeLines splits output into lines and collapses runs of whitespace so +// tabwriter column padding does not make expectations alignment-dependent. +func normalizeLines(s string) []string { + var out []string + for _, ln := range strings.Split(strings.TrimRight(s, "\n"), "\n") { + out = append(out, strings.Join(strings.Fields(ln), " ")) + } + return out +} + +// TestSummaryPrint covers the rendered report: header, name-sorted rows, ok/FAIL +// status, "-" for a missing HTTP status, humanised bytes, millisecond-rounded +// durations, the TOTALS line, and the optional uploaded line. +func TestSummaryPrint(t *testing.T) { + tests := []struct { + description string + sources []SourceResult + uploadURL string + uploadBytes int64 + expectedLines []string + expectErr bool + }{ + // positive + { + description: "positive: two ok sources are rendered sorted by name with totals and an uploaded line", + sources: []SourceResult{ + {Name: "zeta", OK: true, HTTPStatus: 200, FetchedBytes: 2048, Parsed: 3, Valid: 3, Duration: 1500 * time.Millisecond}, + {Name: "alpha", OK: true, HTTPStatus: 200, FetchedBytes: 100, Parsed: 2, Valid: 1, Rejected: 1, Duration: 20 * time.Millisecond, Note: "1 bad cidr"}, + }, + uploadURL: "s3://bucket/ipfeeds/x.parquet", + uploadBytes: 3 * 1024 * 1024, + expectedLines: []string{ + "source status http fetched parsed +valid -rejected dur note", + "alpha ok 200 100 B 2 1 1 20ms 1 bad cidr", + "zeta ok 200 2.0 KB 3 3 0 1.5s", + "", + "TOTALS 2 ok / 0 fail records: 4 valid (+) / 1 rejected (-)", + "uploaded: s3://bucket/ipfeeds/x.parquet (3.0 MB)", + }, + }, + // negative + { + description: "negative: a failed source shows FAIL, '-' for no http status, and its note", + sources: []SourceResult{ + {Name: "broken", OK: false, Duration: 5 * time.Second, Note: "dial tcp: connection refused"}, + }, + expectedLines: []string{ + "source status http fetched parsed +valid -rejected dur note", + "broken FAIL - 0 B 0 0 0 5s dial tcp: connection refused", + "", + "TOTALS 0 ok / 1 fail records: 0 valid (+) / 0 rejected (-)", + }, + }, + { + description: "negative: a writer that fails surfaces a flush error", + sources: []SourceResult{{Name: "a", OK: true}}, + expectErr: true, + }, + // boundary + { + description: "boundary: no sources prints just the header and a zero TOTALS line", + sources: nil, + expectedLines: []string{ + "source status http fetched parsed +valid -rejected dur note", + "", + "TOTALS 0 ok / 0 fail records: 0 valid (+) / 0 rejected (-)", + }, + }, + { + description: "boundary: an ok source with zero records renders zeros and no uploaded line when URL is empty", + sources: []SourceResult{{Name: "empty", OK: true, HTTPStatus: 204}}, + uploadBytes: 999, // ignored without a URL + expectedLines: []string{ + "source status http fetched parsed +valid -rejected dur note", + "empty ok 204 0 B 0 0 0 0s", + "", + "TOTALS 1 ok / 0 fail records: 0 valid (+) / 0 rejected (-)", + }, + }, + // corner + { + description: "corner: a failed source with a non-2xx status still prints the numeric status and sub-ms durations round to 0s", + sources: []SourceResult{ + {Name: "b", OK: false, HTTPStatus: 503, FetchedBytes: 12, Duration: 400 * time.Microsecond, Note: "status 503"}, + {Name: "a", OK: true, HTTPStatus: 200, FetchedBytes: 1, Valid: 1, Duration: 1499 * time.Microsecond}, + }, + expectedLines: []string{ + "source status http fetched parsed +valid -rejected dur note", + "a ok 200 1 B 0 1 0 1ms", + "b FAIL 503 12 B 0 0 0 0s status 503", + "", + "TOTALS 1 ok / 1 fail records: 1 valid (+) / 0 rejected (-)", + }, + }, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var s Summary + for _, r := range tc.sources { + s.Add(r) + } + if tc.expectErr { + err := s.Print(failingWriter{}, tc.uploadURL, tc.uploadBytes) + if err == nil { + t.Fatalf("%s: expected error, got nil", tc.description) + } + if !strings.Contains(err.Error(), "summary: flush table") { + t.Errorf("%s: error %q lacks flush-table context", tc.description, err) + } + return + } + var buf bytes.Buffer + if err := s.Print(&buf, tc.uploadURL, tc.uploadBytes); err != nil { + t.Fatalf("%s: unexpected error: %v", tc.description, err) + } + got := normalizeLines(buf.String()) + if len(got) != len(tc.expectedLines) { + t.Fatalf("%s: got %d lines, want %d\n%s", tc.description, len(got), len(tc.expectedLines), buf.String()) + } + for i := range tc.expectedLines { + if got[i] != tc.expectedLines[i] { + t.Errorf("%s: line %d = %q, want %q", tc.description, i, got[i], tc.expectedLines[i]) + } + } + }) + } +} diff --git a/internal/ipfeed/telemetry/otel.go b/internal/ipfeed/telemetry/otel.go index fa9c60d..45c631a 100644 --- a/internal/ipfeed/telemetry/otel.go +++ b/internal/ipfeed/telemetry/otel.go @@ -1,17 +1,29 @@ -// Package telemetry wires OpenTelemetry (OTLP over HTTP) metrics and traces -// for the collector. If no OTLP endpoint is configured (the standard -// OTEL_EXPORTER_OTLP_ENDPOINT env var is empty), providers are still created -// but without exporters, so the tool runs fine with no collector attached. +// Package telemetry wires OpenTelemetry metrics and traces for the collector. +// +// Metrics reach operators two ways, both driven by the same instruments: +// +// - OTLP over HTTP when the standard OTEL_EXPORTER_OTLP_ENDPOINT env var is +// set (traces go the same way); +// - the Prometheus text format through Telemetry.PrometheusHandler when +// Options.Prometheus is set — the daemon mounts it as /metrics on its +// health server so one port serves probes and scrapes. +// +// With neither configured, providers are still created but without exporters, +// so the tool runs fine with no collector attached. package telemetry import ( "context" + "net/http" "os" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp" "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp" + otelprom "go.opentelemetry.io/otel/exporters/prometheus" "go.opentelemetry.io/otel/metric" sdkmetric "go.opentelemetry.io/otel/sdk/metric" "go.opentelemetry.io/otel/sdk/resource" @@ -19,27 +31,56 @@ import ( "go.opentelemetry.io/otel/trace" ) +// Options tunes Setup. The zero value keeps the OTLP-only behaviour. +type Options struct { + // Prometheus additionally exposes every instrument in the Prometheus text + // format through Telemetry.PrometheusHandler (nil when false). Meant for the + // daemon's health server; a one-shot run has nowhere to be scraped from and + // reports its numbers in the end-of-run summary instead. + Prometheus bool +} + // Telemetry holds the tracer and metric instruments used across the pipeline. +// +// Naming: OTel dotted names; the Prometheus exporter renders them with +// underscores plus the conventional suffixes, e.g. ipfeed.fetch.duration (unit +// s) → ipfeed_fetch_duration_seconds, ipfeed.cycles → ipfeed_cycles_total, +// ipfeed.artifact.size (unit By) → ipfeed_artifact_size_bytes. Every series also +// carries the exporter's otel_scope_name/otel_scope_version labels. type Telemetry struct { Tracer trace.Tracer - FetchBytes metric.Int64Counter - FetchAttempts metric.Int64Counter - FetchFailures metric.Int64Counter - RecordsValid metric.Int64Counter - RecordsInvalid metric.Int64Counter - UploadBytes metric.Int64Counter - Cycles metric.Int64Counter // collection cycles, attr outcome=success|failure - FetchDuration metric.Float64Histogram - ParseDuration metric.Float64Histogram + // Per-source (attributes source, provider). Counters accumulate across + // cycles; the gauge is the latest cycle's view. + FetchBytes metric.Int64Counter + FetchAttempts metric.Int64Counter + FetchFailures metric.Int64Counter + RecordsValid metric.Int64Counter + RecordsInvalid metric.Int64Counter + FetchDuration metric.Float64Histogram // discover + download, seconds + ParseDuration metric.Float64Histogram // parse of the downloaded body, seconds + SourceRecords metric.Int64Gauge // valid records (prefix entries) from the source in the latest cycle + + // Per-cycle (no attributes unless noted). + Cycles metric.Int64Counter // attr outcome=success|failure + CycleDuration metric.Float64Histogram // whole cycle, seconds; attr outcome SourcesSucceeded metric.Int64Gauge + ArtifactRecords metric.Int64Gauge // prefix entries in the artifact just written (the lookup table size) + ArtifactBytes metric.Int64Gauge // size of that Parquet file + WriteDuration metric.Float64Histogram // combine + Parquet write (building the lookup artifact), seconds + UploadBytes metric.Int64Counter + UploadDuration metric.Float64Histogram // S3 PUT, seconds + + // PrometheusHandler serves the instruments above in the Prometheus text + // format. nil unless Options.Prometheus was set. + PrometheusHandler http.Handler shutdown []func(context.Context) error } // Setup builds trace and metric providers for serviceName and returns a // Telemetry with all instruments created. Call Telemetry.Shutdown to flush. -func Setup(ctx context.Context, serviceName string) (*Telemetry, error) { +func Setup(ctx context.Context, serviceName string, opts Options) (*Telemetry, error) { // Use a schemaless resource for the service.name attribute so it merges // cleanly with resource.Default() regardless of the SDK's schema version. res, err := resource.Merge(resource.Default(), @@ -75,6 +116,18 @@ func Setup(ctx context.Context, serviceName string) (*Telemetry, error) { } mpOpts = append(mpOpts, sdkmetric.WithReader(sdkmetric.NewPeriodicReader(mexp))) } + if opts.Prometheus { + // A private registry: the exporter is a pull reader, and keeping it off + // the default registry means a second Setup in one process (tests) does + // not collide on already-registered collectors. + reg := prometheus.NewRegistry() + pexp, err := otelprom.New(otelprom.WithRegisterer(reg)) + if err != nil { + return nil, err + } + mpOpts = append(mpOpts, sdkmetric.WithReader(pexp)) + t.PrometheusHandler = promhttp.HandlerFor(reg, promhttp.HandlerOpts{}) + } mp := sdkmetric.NewMeterProvider(mpOpts...) otel.SetMeterProvider(mp) t.shutdown = append(t.shutdown, mp.Shutdown) @@ -97,21 +150,50 @@ func Setup(ctx context.Context, serviceName string) (*Telemetry, error) { if t.RecordsInvalid, err = m.Int64Counter("ipfeed.records.invalid"); err != nil { return nil, err } - if t.UploadBytes, err = m.Int64Counter("ipfeed.upload.bytes"); err != nil { + if t.FetchDuration, err = m.Float64Histogram("ipfeed.fetch.duration", metric.WithUnit("s"), + metric.WithDescription("Discover + download of one source's feed, per attempt sequence")); err != nil { return nil, err } - if t.Cycles, err = m.Int64Counter("ipfeed.cycles"); err != nil { + if t.ParseDuration, err = m.Float64Histogram("ipfeed.parse.duration", metric.WithUnit("s"), + metric.WithDescription("Parse of one source's downloaded body")); err != nil { return nil, err } - if t.FetchDuration, err = m.Float64Histogram("ipfeed.fetch.duration", metric.WithUnit("s")); err != nil { + if t.SourceRecords, err = m.Int64Gauge("ipfeed.source.records", + metric.WithDescription("Valid prefix records the source contributed in the latest cycle")); err != nil { return nil, err } - if t.ParseDuration, err = m.Float64Histogram("ipfeed.parse.duration", metric.WithUnit("s")); err != nil { + + if t.Cycles, err = m.Int64Counter("ipfeed.cycles"); err != nil { + return nil, err + } + if t.CycleDuration, err = m.Float64Histogram("ipfeed.cycle.duration", metric.WithUnit("s"), + metric.WithDescription("One full collection cycle: fetch all sources, combine, write, upload")); err != nil { return nil, err } if t.SourcesSucceeded, err = m.Int64Gauge("ipfeed.sources.succeeded"); err != nil { return nil, err } + if t.ArtifactRecords, err = m.Int64Gauge("ipfeed.artifact.records", + metric.WithDescription("Prefix records in the Parquet artifact written by the latest cycle (lookup-table entries)")); err != nil { + return nil, err + } + // Named "size" not "bytes": the Prometheus exporter appends the unit, so this + // renders as ipfeed_artifact_size_bytes rather than ipfeed_artifact_bytes_bytes. + if t.ArtifactBytes, err = m.Int64Gauge("ipfeed.artifact.size", metric.WithUnit("By"), + metric.WithDescription("Size of the Parquet artifact written by the latest cycle")); err != nil { + return nil, err + } + if t.WriteDuration, err = m.Float64Histogram("ipfeed.write.duration", metric.WithUnit("s"), + metric.WithDescription("Sort + Parquet write of the combined records (building the lookup artifact)")); err != nil { + return nil, err + } + if t.UploadBytes, err = m.Int64Counter("ipfeed.upload.bytes"); err != nil { + return nil, err + } + if t.UploadDuration, err = m.Float64Histogram("ipfeed.upload.duration", metric.WithUnit("s"), + metric.WithDescription("S3 PUT of the artifact")); err != nil { + return nil, err + } return t, nil } diff --git a/internal/ipfeed/telemetry/otel_test.go b/internal/ipfeed/telemetry/otel_test.go new file mode 100644 index 0000000..9a8511b --- /dev/null +++ b/internal/ipfeed/telemetry/otel_test.go @@ -0,0 +1,169 @@ +package telemetry + +import ( + "context" + "io" + "net/http" + "net/http/httptest" + "regexp" + "testing" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" +) + +// TestSetupPrometheus covers the Prometheus bridge: the handler exists only +// when asked for, every instrument the collector records into is exposed under +// its rendered Prometheus name, gauges show the latest value, and two Setups in +// one process do not collide. +// +// go test ./internal/ipfeed/telemetry/ -run TestSetupPrometheus +func TestSetupPrometheus(t *testing.T) { + src := metric.WithAttributes(attribute.String("source", "gcp-goog"), attribute.String("provider", "gcp")) + okOutcome := metric.WithAttributes(attribute.String("outcome", "success")) + + tests := []struct { + description string + opts Options + record func(ctx context.Context, tel *Telemetry) + wantHandler bool + // wantLines are regexps that must each match one line of the /metrics + // body (label order and the exporter's otel_scope_* labels are not + // pinned, hence [^}]*). + wantLines []string + // wantAbsent are regexps that must match no line. + wantAbsent []string + }{ + // negative — default keeps the OTLP-only behaviour + {"zero Options: no Prometheus handler", Options{}, nil, false, nil, nil}, + + // positive — every new instrument renders under its Prometheus name + {"lookup-table size and build/upload durations are exposed", Options{Prometheus: true}, + func(ctx context.Context, tel *Telemetry) { + tel.ArtifactRecords.Record(ctx, 42) + tel.ArtifactBytes.Record(ctx, 4096) + tel.WriteDuration.Record(ctx, 0.25) + tel.UploadDuration.Record(ctx, 1.5) + tel.CycleDuration.Record(ctx, 2.0, okOutcome) + tel.Cycles.Add(ctx, 1, okOutcome) + }, true, + []string{ + `^ipfeed_artifact_records\{[^}]*\} 42$`, + `^ipfeed_artifact_size_bytes\{[^}]*\} 4096$`, + `^ipfeed_write_duration_seconds_count\{[^}]*\} 1$`, + `^ipfeed_write_duration_seconds_sum\{[^}]*\} 0\.25$`, + `^ipfeed_upload_duration_seconds_count\{[^}]*\} 1$`, + `^ipfeed_cycle_duration_seconds_count\{[^}]*outcome="success"[^}]*\} 1$`, + `^ipfeed_cycles_total\{[^}]*outcome="success"[^}]*\} 1$`, + }, + []string{`^ipfeed_artifact_bytes_bytes`}}, + {"per-source record gauge carries source and provider labels", Options{Prometheus: true}, + func(ctx context.Context, tel *Telemetry) { + tel.SourceRecords.Record(ctx, 3, src) + tel.FetchDuration.Record(ctx, 0.5, src) + tel.FetchBytes.Add(ctx, 1234, src) + }, true, + []string{ + `^ipfeed_source_records\{[^}]*provider="gcp"[^}]*source="gcp-goog"[^}]*\} 3$`, + `^ipfeed_fetch_duration_seconds_count\{[^}]*source="gcp-goog"[^}]*\} 1$`, + `^ipfeed_fetch_bytes_total\{[^}]*source="gcp-goog"[^}]*\} 1234$`, + }, nil}, + + // boundary — a gauge is last-value, a counter accumulates + {"gauge shows the latest value, counter the running total", Options{Prometheus: true}, + func(ctx context.Context, tel *Telemetry) { + tel.ArtifactRecords.Record(ctx, 42) + tel.ArtifactRecords.Record(ctx, 7) + tel.Cycles.Add(ctx, 1, okOutcome) + tel.Cycles.Add(ctx, 1, okOutcome) + }, true, + []string{ + `^ipfeed_artifact_records\{[^}]*\} 7$`, + `^ipfeed_cycles_total\{[^}]*\} 2$`, + }, + []string{`^ipfeed_artifact_records\{[^}]*\} 42$`}}, + + // corner — a zero gauge is still a series (a failed source shows 0, not absence) + {"zero recorded into the source gauge is exposed as 0", Options{Prometheus: true}, + func(ctx context.Context, tel *Telemetry) { tel.SourceRecords.Record(ctx, 0, src) }, true, + []string{`^ipfeed_source_records\{[^}]*source="gcp-goog"[^}]*\} 0$`}, nil}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + // Never try to reach a real OTLP endpoint from a unit test. + t.Setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "") + ctx := context.Background() + tel, err := Setup(ctx, "ipfeed-collector-test", tc.opts) + if err != nil { + t.Fatalf("Setup: %v", err) + } + t.Cleanup(func() { + if err := tel.Shutdown(context.Background()); err != nil { + t.Errorf("Shutdown: %v", err) + } + }) + if (tel.PrometheusHandler != nil) != tc.wantHandler { + t.Fatalf("PrometheusHandler != nil = %v, want %v", tel.PrometheusHandler != nil, tc.wantHandler) + } + if tc.record != nil { + tc.record(ctx, tel) + } + if !tc.wantHandler { + return + } + + rec := httptest.NewRecorder() + tel.PrometheusHandler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("GET /metrics status = %d, want 200", rec.Code) + } + body, err := io.ReadAll(rec.Body) + if err != nil { + t.Fatal(err) + } + for _, pat := range tc.wantLines { + if !regexp.MustCompile("(?m)" + pat).Match(body) { + t.Errorf("no line matches %s\n--- body ---\n%s", pat, body) + } + } + for _, pat := range tc.wantAbsent { + if regexp.MustCompile("(?m)" + pat).Match(body) { + t.Errorf("a line matches %s but must not\n--- body ---\n%s", pat, body) + } + } + }) + } +} + +// TestSetupTwicePrivateRegistry pins the private-registry choice: two +// Prometheus-enabled Setups in one process (as the tests above do) must not +// fail with duplicate-registration errors and must not see each other's data. +func TestSetupTwicePrivateRegistry(t *testing.T) { + t.Setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "") + ctx := context.Background() + a, err := Setup(ctx, "a", Options{Prometheus: true}) + if err != nil { + t.Fatalf("first Setup: %v", err) + } + b, err := Setup(ctx, "b", Options{Prometheus: true}) + if err != nil { + t.Fatalf("second Setup: %v", err) + } + t.Cleanup(func() { _ = a.Shutdown(ctx); _ = b.Shutdown(ctx) }) + + a.ArtifactRecords.Record(ctx, 11) + rec := httptest.NewRecorder() + b.PrometheusHandler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil)) + if regexp.MustCompile(`(?m)^ipfeed_artifact_records\{[^}]*\} 11$`).Match(rec.Body.Bytes()) { + t.Error("second Telemetry's /metrics shows the first Telemetry's gauge (registries are shared)") + } +} + +// TestShutdownNil pins the documented nil no-op so callers can defer Shutdown +// unconditionally. +func TestShutdownNil(t *testing.T) { + var tel *Telemetry + if err := tel.Shutdown(context.Background()); err != nil { + t.Errorf("nil Telemetry Shutdown = %v, want nil", err) + } +} diff --git a/nix/capture-netlink-fixtures.nix b/nix/capture-netlink-fixtures.nix index cd59726..93074aa 100644 --- a/nix/capture-netlink-fixtures.nix +++ b/nix/capture-netlink-fixtures.nix @@ -79,7 +79,13 @@ pkgs.writeShellApplication { sudo "$IP" link add "$IFACE" type nlmon sudo "$IP" link set dev "$IFACE" up - cleanup() { sudo "$IP" link del "$IFACE" 2>/dev/null || true; } + # The trap also chowns $OUT back: tcpdump/tee run as root, so an abort + # halfway (Ctrl-C, a failed dump) would otherwise leave root-owned files + # the unprivileged caller cannot delete or overwrite on the next run. + cleanup() { + sudo "$IP" link del "$IFACE" 2>/dev/null || true + sudo "$CHOWN" -R "$USER_NAME:$GROUP_NAME" "$OUT" 2>/dev/null || true + } trap cleanup EXIT # Capture one dump type into a raw pcap, then filter to NETLINK_ROUTE. @@ -103,6 +109,8 @@ pkgs.writeShellApplication { echo " -> $OUT/$name.pcap ($n NETLINK_ROUTE packets)" } + # Note: `ip addr show` issues an RTM_GETLINK dump before RTM_GETADDR, so the + # getaddr pcaps also carry RTM_NEWLINK replies; parsers filter by type. gen_addr() { "$IP" -4 addr show; "$IP" -6 addr show; } gen_route() { "$IP" route show table all; } gen_link() { "$IP" link show; } diff --git a/nix/containers/default.nix b/nix/containers/default.nix index 86eb999..02ca3b6 100644 --- a/nix/containers/default.nix +++ b/nix/containers/default.nix @@ -77,14 +77,25 @@ let # TCP_PADS bytes of zero-pad per message (default 2048) # TCP_CONNECT host the clients dial (default 127.0.0.1) # TCP_BIND iface the server listens on (default 0.0.0.0) + # TCP_SRCADDR bind clients' source IP (default: kernel picks) + # TCP_IFACE bind clients to this interface (default: kernel picks) + # (SO_BINDTODEVICE — drives xtcp2 interface-name enrichment) MODE="''${TCP_MODE:-both}" COUNT="''${TCP_COUNT:-100}" SLEEP="''${TCP_SLEEP:-5s}" PADS="''${TCP_PADS:-2048}" CONNECT="''${TCP_CONNECT:-127.0.0.1}" BIND="''${TCP_BIND:-0.0.0.0}" + SRCADDR="''${TCP_SRCADDR:-}" + IFACE="''${TCP_IFACE:-}" - echo "tcp-stress: mode=$MODE count=$COUNT sleep=$SLEEP pads=$PADS connect=$CONNECT bind=$BIND" + # Optional source-address / interface binds for the client half. Left out + # entirely when unset so the kernel keeps choosing (original behaviour). + CLIENT_EXTRA=() + if [ -n "$SRCADDR" ]; then CLIENT_EXTRA+=(-srcaddr "$SRCADDR"); fi + if [ -n "$IFACE" ]; then CLIENT_EXTRA+=(-iface "$IFACE"); fi + + echo "tcp-stress: mode=$MODE count=$COUNT sleep=$SLEEP pads=$PADS connect=$CONNECT bind=$BIND srcaddr=''${SRCADDR:-} iface=''${IFACE:-}" case "$MODE" in server) @@ -92,7 +103,7 @@ let ;; client) exec /bin/tcp_client -count "$COUNT" -connect "$CONNECT" \ - -sleep "$SLEEP" -pads "$PADS" + -sleep "$SLEEP" -pads "$PADS" "''${CLIENT_EXTRA[@]}" ;; both) # In single-container mode we run both halves: server in @@ -101,7 +112,7 @@ let /bin/tcp_server -count "$COUNT" -bind "$BIND" & sleep 2 exec /bin/tcp_client -count "$COUNT" -connect "$CONNECT" \ - -sleep "$SLEEP" -pads "$PADS" + -sleep "$SLEEP" -pads "$PADS" "''${CLIENT_EXTRA[@]}" ;; *) echo "unknown TCP_MODE: $MODE (want: server | client | both)" >&2 diff --git a/nix/default.nix b/nix/default.nix index 3695f12..f1c01fe 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -520,6 +520,7 @@ in microvm-x86_64-coverage-iouring = microvms.vmsCoverageIoUring.x86_64; microvm-x86_64-soak = microvms.vmsSoak.x86_64; microvm-x86_64-tcp-stress = microvms.vmsTcpStress.x86_64; + microvm-x86_64-interface-naming = microvms.vmsInterfaceNaming.x86_64; microvm-x86_64-clickhouse-pipeline = microvms.vmsClickPipe.x86_64; microvm-x86_64-clickhouse-http = microvms.vmsClickHttp.x86_64; microvm-x86_64-clickhouse-pipeline-rate = microvms.vmsClickPipeRate.x86_64; @@ -563,6 +564,7 @@ in test-microvm-lifecycle-x86_64-unixgram-sink = microvms.lifecycleUnixgramSink.x86_64.fullTest; test-microvm-lifecycle-x86_64-nats = microvms.lifecycleNats.x86_64.fullTest; test-microvm-lifecycle-x86_64-nsq = microvms.lifecycleNsq.x86_64.fullTest; + test-microvm-lifecycle-x86_64-interface-naming = microvms.lifecycleInterfaceNaming.x86_64.fullTest; test-microvm-lifecycle-x86_64-coverage = microvms.lifecycleCoverage.x86_64.fullTest; test-microvm-lifecycle-x86_64-coverage-iouring = microvms.lifecycleCoverageIoUring.x86_64.fullTest; diff --git a/nix/devshell.nix b/nix/devshell.nix index ff6d904..43b3f9f 100644 --- a/nix/devshell.nix +++ b/nix/devshell.nix @@ -55,6 +55,10 @@ pkgs.mkShell { Tests: go test ./... Unit tests + go test -ldflags=-checklinkname=0 ./pkg/xtcp/ ./cmd/xtcp2/ + Local workaround when the toolchain + rejects giouring's syscall linkname + ("invalid reference to syscall.munmap") nix build .#tests.microvm-lifecycle Boot xtcp2 in a VM and verify Nix: diff --git a/nix/microvms/default.nix b/nix/microvms/default.nix index ad5d845..43c49e6 100644 --- a/nix/microvms/default.nix +++ b/nix/microvms/default.nix @@ -109,6 +109,23 @@ let sink = "tcp-stress"; }; + # interface-naming: docker-free host-ns veth topology that proves xtcp2 stamps + # the correct bound + egress interface names (see mkVm.nix isInterfaceNaming). + mkOneInterfaceNaming = + arch: + import ./mkVm.nix { + inherit + pkgs + lib + microvm + nixpkgs + arch + xtcp2Package + xtcp2AllPackage + ; + sink = "interface-naming"; + }; + mkOneClickPipe = arch: import ./mkVm.nix { @@ -389,6 +406,8 @@ let lib.genAttrs constants.supportedArchs mkOneTcpStress ); + vmsInterfaceNaming = lib.genAttrs constants.supportedArchs mkOneInterfaceNaming; + vmsClickPipe = lib.genAttrs constants.supportedArchs mkOneClickPipe; vmsClickHttp = lib.genAttrs constants.supportedArchs mkOneClickHttp; @@ -437,6 +456,27 @@ let }; }); + # interface-naming lifecycle: boots the veth-topology VM and greps the IFNAME + # and ASN verdicts (the flavor also runs the loopback ipfeed-collector → xtcp2 + # -enrichAsn chain, see mkVm.nix asnDbPath). Native (no docker), but the + # self-test polls the jsonl for up to ~2 min per check while the locality + # snapshot refreshes, the artifact lands and records accrue, so keep a + # generous timeout. + lifecycleInterfaceNaming = lib.genAttrs constants.supportedArchs (arch: { + fullTest = microvmLib.mkLifecycleFullTest { + inherit arch; + vm = vmsInterfaceNaming.${arch}; + suffix = "-interface-naming"; + extraSentinels = [ + "IFNAME" + "ASN" + ]; + # Boot + checks 1–5e take ~4 min on a loaded host before 5f/5g even start, + # and each of those polls for up to 2 min. + timeoutSec = 600; + }; + }); + lifecycleValkey = lib.genAttrs constants.supportedArchs (arch: { fullTest = microvmLib.mkLifecycleFullTest { inherit arch; @@ -729,6 +769,8 @@ in lifecycleNsq lifecycleCoverage lifecycleCoverageIoUring + lifecycleInterfaceNaming + vmsInterfaceNaming soak tcpStress checks diff --git a/nix/microvms/mkVm.nix b/nix/microvms/mkVm.nix index 33a1301..de58cbc 100644 --- a/nix/microvms/mkVm.nix +++ b/nix/microvms/mkVm.nix @@ -109,6 +109,16 @@ let # can validate the daemon's serialized output content (OUTPUT_CONTENT check). isMinimal = sink == "minimal"; isTcpStress = sink == "tcp-stress"; + # interface-naming = a docker-free host-ns flavor that proves xtcp2 names + # interfaces correctly end-to-end. It builds two veth pairs (a peer netns holds + # the far ends), runs the tcp_client/tcp_server generators bound to specific + # interfaces, and enables -enrichLocality so the self-test can assert the bound + # (idiag_if) and route-egress interface names on the daemon's jsonl records. + # It reuses the tcp-stress socket generators but NOT docker: docker containers + # get their own netns and cannot see host veth/dummy interfaces, so the + # SO_BINDTODEVICE + custom-egress topology the user asked for must live in the + # host ns where xtcp2 also reads it. + isInterfaceNaming = sink == "interface-naming"; # clickhouse-pipeline = tcp-stress + redpanda + clickhouse + kafka # destination. Same docker setup but two extra containers + xtcp2 # configured with -dest kafka:localhost:19092 so the records flow @@ -259,6 +269,22 @@ let # minimal flavor only: validate the daemon's jsonl file-dest output. runFileOutputCheck = isMinimal; inherit fileOutputPath; + # interface-naming flavor only: assert the bound + egress interface names. + runInterfaceNamingCheck = isInterfaceNaming; + ifnameBound = ifnBoundIf; + ifnameEgress = ifnEgrIf; + # interface-naming flavor only: assert the ASN enrichment on the 8.8.8.8:53 + # record produced by the xtcp2-asn-dialer unit, and the loadAsn/prefixes + # gauge against the fixture's prefix count. + runAsnCheck = isInterfaceNaming; + inherit + asnDbPath + asnDialTarget + asnDialPort + asnExpectedAsn + asnExpectedOwner + asnExpectedPrefixes + ; # tcp-sink flavor only: validate records received over the raw TCP dest. runRawSocketCheck = isSocketSink; inherit @@ -308,6 +334,124 @@ let tcpStressClientSleep = "5s"; tcpStressPads = 1024; + # interface-naming flavor topology. Two veth pairs whose far ends live in a + # dedicated peer netns so each connected /24 has exactly one owning device in + # the host ns (no route ambiguity). The host ns runs the clients; the peer ns + # runs the echo servers. Interface names must be <=15 chars. + # ifn-bound (10.88.1.1/24) <-> ifn-boundp (10.88.1.2/24, peer ns) + # ifn-egr (10.88.2.1/24) <-> ifn-egrp (10.88.2.2/24, peer ns) + # A dummy + bridge are added purely for naming variety (not asserted). + ifnPeerNs = "ifnpeer"; + ifnBoundIf = "ifn-bound"; + ifnBoundPeer = "ifn-boundp"; + ifnBoundHostIp = "10.88.1.1"; + ifnBoundPeerIp = "10.88.1.2"; + ifnEgrIf = "ifn-egr"; + ifnEgrPeer = "ifn-egrp"; + ifnEgrHostIp = "10.88.2.1"; + ifnEgrPeerIp = "10.88.2.2"; + ifnSocketCount = 24; + ifnServerCount = 64; + + # ASN enrichment (interface-naming flavor). Proves the whole ASN chain end to + # end without touching the internet for the *feed*: a synthetic goog.json in + # the real gstatic format (Google's public-DNS ranges only) is served over + # loopback, ipfeed-collector runs its real fetch → parse → asnmap → Parquet + # pipeline against it, and xtcp2 (-enrichAsn) loads the artifact. A dialer + # holds a TCP connection to ${asnDialTarget}:${toString asnDialPort} so the + # daemon emits a LOCALITY_REMOTE record whose destination matches 8.8.8.0/24 + # → AS15169 / network_owner "google" (the ASN self-test check asserts that). + # The collector is deliberately ordered AFTER xtcp2 so the artifact arrives + # late and the daemon's retry-on-tick path (not just the startup load) is + # what installs it. + asnFeedPort = 8099; + asnDir = "/run/xtcp2-asn"; + asnDbPath = "${asnDir}/asn.parquet"; + asnDialTarget = "8.8.8.8"; + asnDialPort = 53; + asnExpectedAsn = "15169"; + asnExpectedOwner = "google"; + asnFeedPrefixes = [ + { ipv4Prefix = "8.8.4.0/24"; } + { ipv4Prefix = "8.8.8.0/24"; } + { ipv6Prefix = "2001:4860:4860::/48"; } + ]; + # The daemon's loadAsn/prefixes gauge must equal the fixture's prefix count + # (derived, so adding a prefix above cannot silently desynchronise the check). + asnExpectedPrefixes = toString (builtins.length asnFeedPrefixes); + asnFeedFixture = pkgs.writeTextDir "goog.json" ( + builtins.toJSON { + syncToken = "1700000000000"; + creationTime = "2026-01-01T00:00:00.000000"; + prefixes = asnFeedPrefixes; + } + ); + # Same shape as cmd/ipfeed-collector/sources/gcp-goog.yaml with the URL + # pointed at the in-VM fixture server. + asnSourcesDir = pkgs.writeTextDir "gcp-goog.yaml" '' + name: gcp-goog + provider: gcp + url: http://127.0.0.1:${toString asnFeedPort}/goog.json + parser: gcp_ipranges + source_type: provider_feed + confidence: authoritative + defaults: + network_owner: google + service_operator: google + enabled: true + ''; + + # Builds the host-ns + peer-ns veth topology. Idempotent-ish: it tears down a + # previous run's netns/links first so a service restart re-converges cleanly. + ifnameNetSetupScript = pkgs.writeShellApplication { + name = "xtcp2-ifname-netsetup"; + runtimeInputs = with pkgs; [ + iproute2 + coreutils + ]; + text = '' + # Best-effort teardown of any prior run (ignore missing). + ip netns del ${ifnPeerNs} 2>/dev/null || true + ip link del ${ifnBoundIf} 2>/dev/null || true + ip link del ${ifnEgrIf} 2>/dev/null || true + ip link del ifn-dummy 2>/dev/null || true + ip link del ifn-br 2>/dev/null || true + + ip netns add ${ifnPeerNs} + ip -n ${ifnPeerNs} link set lo up + + # veth pairs; move the far ends into the peer netns. + ip link add ${ifnBoundIf} type veth peer name ${ifnBoundPeer} + ip link add ${ifnEgrIf} type veth peer name ${ifnEgrPeer} + ip link set ${ifnBoundPeer} netns ${ifnPeerNs} + ip link set ${ifnEgrPeer} netns ${ifnPeerNs} + + # Host ns near ends + on-link /24 routes (auto-added by ip addr add). + ip addr add ${ifnBoundHostIp}/24 dev ${ifnBoundIf} + ip addr add ${ifnEgrHostIp}/24 dev ${ifnEgrIf} + ip link set ${ifnBoundIf} up + ip link set ${ifnEgrIf} up + + # Peer ns far ends. + ip -n ${ifnPeerNs} addr add ${ifnBoundPeerIp}/24 dev ${ifnBoundPeer} + ip -n ${ifnPeerNs} addr add ${ifnEgrPeerIp}/24 dev ${ifnEgrPeer} + ip -n ${ifnPeerNs} link set ${ifnBoundPeer} up + ip -n ${ifnPeerNs} link set ${ifnEgrPeer} up + + # Extra host-ns interfaces for naming variety (dummy + bridge). Not asserted + # by the self-test but exercise the RTM_GETLINK ifindex->name resolution. + ip link add ifn-dummy type dummy + ip addr add 10.88.9.1/24 dev ifn-dummy + ip link set ifn-dummy up + ip link add ifn-br type bridge + ip addr add 10.88.8.1/24 dev ifn-br + ip link set ifn-br up + + echo "xtcp2-ifname-netsetup: topology ready" + ip -br addr show + ''; + }; + # Phase E clickhouse-pipeline tunables. Image tags are deliberately # exposed here so a future tag bump doesn't require touching the # ExecStart strings deep in the systemd unit defs. @@ -2150,6 +2294,26 @@ in # nsq flavor: PUBLISH each poll's records to the in-VM nsqd topic; # the self-test reads nsqd's per-channel finish_count. xtcp2NsqArgs + else if isInterfaceNaming then + # interface-naming: jsonl to a file (so the IFNAME check can read + # the enrich_socket_*_ifname fields) + the locality enricher. The + # 5s refresh re-dumps the routing table shortly after the veths come + # up, so records get the interface names even if xtcp2 raced ahead. + # -enrichAsn against the collector-produced artifact; the 5s refresh + # is what picks the late-arriving file up (see asnDbPath above). + ( + xtcp2FileArgs + ++ [ + "-enrichLocality" + "-localityRefreshInterval" + "5s" + "-enrichAsn" + "-asnDbPath" + asnDbPath + "-asnRefreshInterval" + "5s" + ] + ) else if isMinimal then # minimal (lifecycle) writes jsonl to a file so OUTPUT_CONTENT # can validate the daemon's serialized output. @@ -2473,6 +2637,191 @@ in }; }; + # ── interface-naming flavor: host-ns veth topology + generators ────── + # netsetup builds the veth pairs + peer netns BEFORE xtcp2 starts so the + # host-ns routing table (which xtcp2 dumps for locality) already names the + # veths. Ordered before xtcp2.service the same way the coverage prep + # oneshot is. + # ── ASN enrichment chain (interface-naming flavor) ───────────────── + # 1. Loopback HTTP server for the synthetic goog.json fixture. + systemd.services.xtcp2-asn-feed = lib.mkIf isInterfaceNaming { + description = "asn — loopback HTTP server for the synthetic goog.json feed"; + wantedBy = [ "multi-user.target" ]; + after = [ "network.target" ]; + serviceConfig = { + Type = "simple"; + ExecStart = "${pkgs.python3}/bin/python3 -m http.server ${toString asnFeedPort} --bind 127.0.0.1 --directory ${asnFeedFixture}"; + Restart = "always"; + RestartSec = "1s"; + StandardOutput = "journal"; + StandardError = "journal"; + }; + }; + + # 2. The real collector, one shot, writing the Parquet artifact xtcp2 + # reads. Ordered after xtcp2 on purpose (late-arriving artifact → + # daemon retry path). The collector's own fetch retries cover the + # fixture server still coming up. + systemd.services.xtcp2-asn-collector = lib.mkIf isInterfaceNaming { + description = "asn — ipfeed-collector builds ${asnDbPath} from the loopback feed"; + wantedBy = [ "multi-user.target" ]; + after = [ + "xtcp2-asn-feed.service" + "xtcp2.service" + ]; + requires = [ "xtcp2-asn-feed.service" ]; + serviceConfig = { + Type = "oneshot"; + RemainAfterExit = true; + # RuntimeDirectory lives as long as this (RemainAfterExit) unit does. + RuntimeDirectory = baseNameOf asnDir; + RuntimeDirectoryMode = "0755"; + ExecStart = "${xtcp2AllPackage}/bin/ipfeed-collector -sources-dir ${asnSourcesDir} -out-file ${asnDbPath} -no-upload -max-attempts 20 -backoff-base 500ms -backoff-cap 5s -v"; + StandardOutput = "journal+console"; + StandardError = "journal+console"; + }; + }; + + # 3. Hold a TCP connection to ${asnDialTarget}:${toString asnDialPort} + # (Google public DNS over TCP) so xtcp2 sees a REMOTE socket whose + # destination is inside the fixture's 8.8.8.0/24. Google closes an + # idle DNS/TCP connection after a few seconds and the VM's SLiRP + # NAT may not reach the internet at all — either way the loop + # re-dials, so a socket to 8.8.8.8 (ESTABLISHED, or SYN_SENT if the + # host is offline) exists for most of the self-test window. + systemd.services.xtcp2-asn-dialer = lib.mkIf isInterfaceNaming { + description = "asn — hold a TCP connection to ${asnDialTarget}:${toString asnDialPort}"; + wantedBy = [ "multi-user.target" ]; + after = [ "network-online.target" ]; + wants = [ "network-online.target" ]; + serviceConfig = { + Type = "simple"; + ExecStart = "${pkgs.bash}/bin/bash -c 'exec 3<>/dev/tcp/${asnDialTarget}/${toString asnDialPort}; sleep 15'"; + Restart = "always"; + RestartSec = "1s"; + StandardOutput = "journal"; + StandardError = "journal"; + }; + }; + + systemd.services.xtcp2-ifname-netsetup = lib.mkIf isInterfaceNaming { + description = "interface-naming — build veth topology + peer netns"; + wantedBy = [ + "multi-user.target" + "xtcp2.service" + ]; + # The generators are useless without the topology: make them hard + # dependents (Requires=, not Wants=) so a failed netsetup stops them + # with a clear dependency error instead of letting them crash-loop + # against missing interfaces. + requiredBy = [ + "xtcp2-ifname-server.service" + "xtcp2-ifname-client-bound.service" + "xtcp2-ifname-client-egress.service" + ]; + before = [ "xtcp2.service" ]; + after = [ "network-pre.target" ]; + serviceConfig = { + Type = "oneshot"; + RemainAfterExit = true; + ExecStart = "${ifnameNetSetupScript}/bin/xtcp2-ifname-netsetup"; + AmbientCapabilities = [ + "CAP_NET_ADMIN" + "CAP_SYS_ADMIN" + ]; + CapabilityBoundingSet = [ + "CAP_NET_ADMIN" + "CAP_SYS_ADMIN" + ]; + StandardOutput = "journal+console"; + StandardError = "journal+console"; + }; + }; + + # Echo servers live in the peer netns, listening on 0.0.0.0 so both veth + # far-end addresses (10.88.1.2 / 10.88.2.2) are reachable. + systemd.services.xtcp2-ifname-server = lib.mkIf isInterfaceNaming { + description = "interface-naming — peer-ns tcp_server echo listeners"; + after = [ "xtcp2-ifname-netsetup.service" ]; + wants = [ "xtcp2-ifname-netsetup.service" ]; + wantedBy = [ "multi-user.target" ]; + serviceConfig = { + Type = "simple"; + ExecStart = "${pkgs.iproute2}/bin/ip netns exec ${ifnPeerNs} ${xtcp2AllPackage}/bin/tcp_server -count ${toString ifnServerCount} -bind 0.0.0.0"; + Restart = "on-failure"; + RestartSec = "2s"; + LimitNOFILE = 65536; + AmbientCapabilities = [ + "CAP_NET_ADMIN" + "CAP_SYS_ADMIN" + ]; + CapabilityBoundingSet = [ + "CAP_NET_ADMIN" + "CAP_SYS_ADMIN" + ]; + StandardOutput = "journal"; + StandardError = "journal+console"; + }; + }; + + # Client A (host ns): SO_BINDTODEVICE-bound to ${ifnBoundIf}, dialing the + # peer reachable on that veth → drives enrich_socket_interface_name. + # SO_BINDTODEVICE has been unprivileged since Linux 5.7; CAP_NET_RAW is + # granted anyway so the unit also works on an older guest kernel. + # Restart=always: the generator exits normally when its connections + # finish (or the peer server restarts), and the self-test needs the + # ESTABLISHED sockets to keep existing while it polls the jsonl. + systemd.services.xtcp2-ifname-client-bound = lib.mkIf isInterfaceNaming { + description = "interface-naming — host-ns tcp_client bound to ${ifnBoundIf}"; + after = [ + "xtcp2-ifname-server.service" + "xtcp2-ifname-netsetup.service" + ]; + wants = [ + "xtcp2-ifname-server.service" + "xtcp2-ifname-netsetup.service" + ]; + wantedBy = [ "multi-user.target" ]; + serviceConfig = { + Type = "simple"; + ExecStartPre = "${pkgs.coreutils}/bin/sleep 2"; + ExecStart = "${xtcp2AllPackage}/bin/tcp_client -count ${toString ifnSocketCount} -connect ${ifnBoundPeerIp} -iface ${ifnBoundIf} -sleep ${tcpStressClientSleep} -pads 512"; + Restart = "always"; + RestartSec = "2s"; + LimitNOFILE = 65536; + AmbientCapabilities = [ "CAP_NET_RAW" ]; + CapabilityBoundingSet = [ "CAP_NET_RAW" ]; + StandardOutput = "journal"; + StandardError = "journal+console"; + }; + }; + + # Client B (host ns): unbound, dialing the peer whose route egresses + # ${ifnEgrIf} → drives enrich_socket_dest_egress_ifname. Restart=always + # for the same reason as client A. + systemd.services.xtcp2-ifname-client-egress = lib.mkIf isInterfaceNaming { + description = "interface-naming — host-ns tcp_client egress via ${ifnEgrIf}"; + after = [ + "xtcp2-ifname-server.service" + "xtcp2-ifname-netsetup.service" + ]; + wants = [ + "xtcp2-ifname-server.service" + "xtcp2-ifname-netsetup.service" + ]; + wantedBy = [ "multi-user.target" ]; + serviceConfig = { + Type = "simple"; + ExecStartPre = "${pkgs.coreutils}/bin/sleep 2"; + ExecStart = "${xtcp2AllPackage}/bin/tcp_client -count ${toString ifnSocketCount} -connect ${ifnEgrPeerIp} -sleep ${tcpStressClientSleep} -pads 512"; + Restart = "always"; + RestartSec = "2s"; + LimitNOFILE = 65536; + StandardOutput = "journal"; + StandardError = "journal+console"; + }; + }; + # Enable docker daemon for any flavor that needs it. Adds # ~150 MiB to the VM image (dockerd + containerd) but keeps the # rest of the surface minimal — no docker-buildx, no compose. diff --git a/nix/microvms/self-test.nix b/nix/microvms/self-test.nix index cddc7c6..f13b92b 100644 --- a/nix/microvms/self-test.nix +++ b/nix/microvms/self-test.nix @@ -89,6 +89,12 @@ # nsqd AND finished by an nsq_tail # consumer (nsqd /stats finish_count) # XTCP2_SELF_TEST_OVERALL_{PASS,FAIL} overall outcome +# XTCP2_SELF_TEST_ASN_{PASS,FAIL} (interface-naming only) ASN +# enrichment end to end: the record +# for the held 8.8.8.8:53 socket +# carries AS15169 / google / +# LOCALITY_REMOTE from an artifact +# the real ipfeed-collector built # # Each check is independent: failure of one does not skip the others, so the # launcher can attribute failures precisely. @@ -191,6 +197,30 @@ # request (idiag_ext=254) yields NO MEMINFO attribute, confirming the dropped # meminfo is not merely un-parsed but never sent by the kernel. runNlProbeCheck ? false, + # When true (interface-naming flavor), Check 5f validates that xtcp2 stamped + # the correct interface names: a record whose socket was SO_BINDTODEVICE-bound + # to ifnameBound carries that name in enrich_socket_interface_name, and a record + # whose destination routes out ifnameEgress carries that name in + # enrich_socket_dest_egress_ifname. Reads the daemon jsonl at fileOutputPath. + runInterfaceNamingCheck ? false, + ifnameBound ? "", + ifnameEgress ? "", + # When true (interface-naming flavor), Check 5g validates ASN enrichment end + # to end: the xtcp2-asn-collector unit builds asnDbPath from a loopback feed, + # xtcp2 (-enrichAsn) loads it, and the xtcp2-asn-dialer unit holds a TCP + # connection to asnDialTarget:asnDialPort. A jsonl record for that socket must + # carry enrich_socket_dest_asn == asnExpectedAsn, network_owner == + # asnExpectedOwner and LOCALITY_REMOTE, and the daemon's + # xtcp_gauges{function="loadAsn",variable="prefixes"} must equal + # asnExpectedPrefixes (the number of prefixes in the fixture feed). Reads the + # daemon jsonl at fileOutputPath and /metrics on promPort. + runAsnCheck ? false, + asnDbPath ? "", + asnDialTarget ? "8.8.8.8", + asnDialPort ? 53, + asnExpectedAsn ? "15169", + asnExpectedOwner ? "google", + asnExpectedPrefixes ? "3", }: pkgs.writeShellApplication { @@ -525,6 +555,156 @@ pkgs.writeShellApplication { fi if [ "$check5e" -ne 0 ]; then overall_ok=0; fi + # ─── Check 5f: interface-naming enrichment content ──────────────────── + # (interface-naming flavor only.) The in-VM generator holds ESTABLISHED + # sockets open: one SO_BINDTODEVICE-bound to ${ifnameBound} (dialing a peer + # reachable on that veth), and one unbound dialing a peer whose route egresses + # ${ifnameEgress}. xtcp2 (-enrichLocality) must stamp those interface names. + # The two records must be distinguishable, not just present somewhere: + # bound — enrichSocketInterfaceName == ${ifnameBound} AND the kernel's own + # idiag_if (inetDiagMsgSocketInterface) is set, proving the name + # was resolved from the socket's bound ifindex, not a route; + # egress — enrichSocketDestEgressIfname == ${ifnameEgress} on a record with + # NO bound-interface name (the unbound client) whose destination + # classified as LOCALITY_LOCAL_SUBNET (peer on the connected /24). + # We poll the jsonl because the locality snapshot is discovered on the + # reconcile path a few seconds after the veths come up. Runs after 5e so the + # generators have had the longest possible time to come up. + ${lib.optionalString runInterfaceNamingCheck '' + echo "--- check 5f: interface-naming (bound=${ifnameBound} egress=${ifnameEgress}) ---" + check5f=1 + boundOk=0 + egressOk=0 + for _ in $(seq 1 60); do + if [ -s "${fileOutputPath}" ]; then + cp "${fileOutputPath}" /tmp/xtcp2-ifname.snap 2>/dev/null || true + if [ "$boundOk" -eq 0 ] && \ + jq -e --arg n "${ifnameBound}" \ + 'select(.enrichSocketInterfaceName == $n + and .inetDiagMsgSocketInterface != null)' \ + /tmp/xtcp2-ifname.snap >/dev/null 2>&1; then + boundOk=1 + fi + if [ "$egressOk" -eq 0 ] && \ + jq -e --arg n "${ifnameEgress}" \ + 'select(.enrichSocketDestEgressIfname == $n + and (.enrichSocketInterfaceName // "") == "" + and .enrichSocketDestLocality == "LOCALITY_LOCAL_SUBNET")' \ + /tmp/xtcp2-ifname.snap >/dev/null 2>&1; then + egressOk=1 + fi + if [ "$boundOk" -eq 1 ] && [ "$egressOk" -eq 1 ]; then break; fi + fi + sleep 2 + done + if [ "$boundOk" -eq 1 ] && [ "$egressOk" -eq 1 ]; then + echo "XTCP2_SELF_TEST_IFNAME_PASS (bound=${ifnameBound} egress=${ifnameEgress})" + check5f=0 + else + echo "XTCP2_SELF_TEST_IFNAME_FAIL (bound_seen=$boundOk egress_seen=$egressOk)" + echo "--- sample records carrying interface fields ---" + jq -c 'select(.enrichSocketInterfaceName != null or .enrichSocketDestEgressIfname != null) + | {i: .enrichSocketInterfaceName, b: .inetDiagMsgSocketInterface, + e: .enrichSocketDestEgressIfname, l: .enrichSocketDestLocality}' \ + /tmp/xtcp2-ifname.snap 2>/dev/null | head -5 || true + fi + if [ "$check5f" -ne 0 ]; then overall_ok=0; fi + ''} + + # ─── Check 5g: ASN enrichment content ────────────────────────────────── + # (interface-naming flavor only.) The xtcp2-asn-dialer unit keeps a TCP + # connection to ${asnDialTarget}:${toString asnDialPort} alive; the + # xtcp2-asn-collector unit builds ${asnDbPath} (real ipfeed-collector against + # a loopback goog.json fixture) AFTER xtcp2 started, so the daemon has to + # pick the artifact up on its -asnRefreshInterval tick. We want the record + # for that exact socket (destination bytes == the dial target, dport == the + # dial port) to carry the representative ASN, the network owner, and a + # REMOTE locality (8.8.8.8 is behind the default gateway). enrich_socket_ + # dest_asn is a uint64, which protojson renders as a JSON *string*. + ${lib.optionalString runAsnCheck '' + echo "--- check 5g: asn enrichment (dest=${asnDialTarget}:${toString asnDialPort} want asn=${asnExpectedAsn} owner=${asnExpectedOwner}) ---" + check5g=1 + # protojson renders idiag_dst as base64. The daemon copies the kernel's + # raw __be32[4] (16 bytes) for every family, so a v4 address is the 4 + # octets followed by 12 zero bytes; accept the bare 4-byte form as well + # so a future trim of v4 addresses does not break the check. Each octet → + # \0NNN octal escape → raw byte via printf %b. + dest_raw=$(IFS=. read -r o1 o2 o3 o4 <<<"${asnDialTarget}"; \ + printf '\\0%03o\\0%03o\\0%03o\\0%03o' "$o1" "$o2" "$o3" "$o4") + dest_b64_4=$(printf '%b' "$dest_raw" | base64) + dest_b64_16=$({ printf '%b' "$dest_raw"; head -c 12 /dev/zero; } | base64) + echo "expecting inetDiagMsgSocketDestination=$dest_b64_16 (or $dest_b64_4)" + artifact_seen=0 + asnOk=0 + for _ in $(seq 1 60); do + if [ "$artifact_seen" -eq 0 ] && [ -s "${asnDbPath}" ]; then + artifact_seen=1 + echo "asn artifact present: $(ls -la ${asnDbPath})" + fi + if [ -s "${fileOutputPath}" ]; then + cp "${fileOutputPath}" /tmp/xtcp2-asn.snap 2>/dev/null || true + if jq -e --arg d4 "$dest_b64_4" --arg d16 "$dest_b64_16" \ + --argjson p ${toString asnDialPort} \ + --arg a "${asnExpectedAsn}" --arg o "${asnExpectedOwner}" \ + 'select((.inetDiagMsgSocketDestination == $d16 or .inetDiagMsgSocketDestination == $d4) + and .inetDiagMsgSocketDestinationPort == $p + and .enrichSocketDestAsn == $a + and .enrichSocketDestNetworkOwner == $o + and .enrichSocketDestLocality == "LOCALITY_REMOTE")' \ + /tmp/xtcp2-asn.snap >/dev/null 2>&1; then + asnOk=1 + break + fi + fi + sleep 2 + done + # The lookup table's own metrics: the prefixes gauge must equal the number + # of prefixes in the fixture feed once the artifact is loaded (a record + # with the right ASN proves a load happened, so the gauge must be there). + # client_golang sorts label pairs by name, so match labels individually + # rather than pinning their order. + echo "--- daemon loadAsn / refreshAsn metrics ---" + asn_metrics=$(curl -sf "http://127.0.0.1:${toString promPort}/metrics" 2>/dev/null || true) + grep -E 'loadAsn|refreshAsn|initAsnEnricher' <<<"$asn_metrics" || echo "(no asn metrics yet)" + asn_prefixes=$(grep -E '^xtcp_gauges\{[^}]*function="loadAsn"[^}]*variable="prefixes"[^}]*\} ' <<<"$asn_metrics" \ + | awk '{print $2}' | head -1) + prefixesOk=0 + if [ "$asn_prefixes" = "${asnExpectedPrefixes}" ]; then prefixesOk=1; fi + if [ "$asnOk" -eq 1 ] && [ "$prefixesOk" -eq 1 ]; then + echo "XTCP2_SELF_TEST_ASN_PASS (dest=${asnDialTarget}:${toString asnDialPort} asn=${asnExpectedAsn} owner=${asnExpectedOwner} prefixes=$asn_prefixes)" + jq -c --arg d4 "$dest_b64_4" --arg d16 "$dest_b64_16" \ + 'select(.inetDiagMsgSocketDestination == $d16 or .inetDiagMsgSocketDestination == $d4) + | {state: .inetDiagMsgState, dport: .inetDiagMsgSocketDestinationPort, + asn: .enrichSocketDestAsn, owner: .enrichSocketDestNetworkOwner, + locality: .enrichSocketDestLocality}' \ + /tmp/xtcp2-asn.snap 2>/dev/null | head -3 || true + check5g=0 + else + echo "XTCP2_SELF_TEST_ASN_FAIL (artifact_seen=$artifact_seen asn_seen=$asnOk prefixes_gauge=''${asn_prefixes:-absent} want=${asnExpectedPrefixes})" + echo "--- records to the dial target (any enrichment) ---" + jq -c --arg d4 "$dest_b64_4" --arg d16 "$dest_b64_16" \ + 'select(.inetDiagMsgSocketDestination == $d16 or .inetDiagMsgSocketDestination == $d4) + | {state: .inetDiagMsgState, dport: .inetDiagMsgSocketDestinationPort, + asn: .enrichSocketDestAsn, owner: .enrichSocketDestNetworkOwner, + locality: .enrichSocketDestLocality}' \ + /tmp/xtcp2-asn.snap 2>/dev/null | head -5 || true + echo "--- live sockets to the dial target (kernel view) ---" + ss -tn "dst ${asnDialTarget}" 2>&1 | head -10 || true + echo "--- records to the dial target, count / any record on dport ${toString asnDialPort} ---" + jq -c --arg d4 "$dest_b64_4" --arg d16 "$dest_b64_16" \ + 'select(.inetDiagMsgSocketDestination == $d16 or .inetDiagMsgSocketDestination == $d4)' \ + /tmp/xtcp2-asn.snap 2>/dev/null | wc -l || true + jq -c --argjson p ${toString asnDialPort} 'select(.inetDiagMsgSocketDestinationPort == $p) + | {family: .inetDiagMsgFamily, dst: .inetDiagMsgSocketDestination, + asn: .enrichSocketDestAsn, locality: .enrichSocketDestLocality}' \ + /tmp/xtcp2-asn.snap 2>/dev/null | head -3 || true + echo "--- collector / dialer unit state ---" + systemctl --no-pager status xtcp2-asn-collector.service xtcp2-asn-dialer.service 2>&1 | head -30 || true + journalctl --no-pager -u xtcp2-asn-dialer.service -n 8 2>&1 || true + fi + if [ "$check5g" -ne 0 ]; then overall_ok=0; fi + ''} + # ─── Check 5f: raw socket destination → in-VM ncat sink ─────────────── # (socket-sink flavors: tcp/udp/unix/unixgram). xtcp2 streams jsonl records # over `-dest :...` to an ncat receiver; validate the received diff --git a/nix/versions.nix b/nix/versions.nix index e642eb8..fdbe9bb 100644 --- a/nix/versions.nix +++ b/nix/versions.nix @@ -117,5 +117,5 @@ # Go vendor hash. Update by running `nix build .#xtcp2` and pasting the # `got:` value from the hash mismatch error. Used by every Nix check that # needs deps in the sandbox (see nix/lib/goModules.nix). - goVendorHash = "sha256-FKOdkCYc/MqR+ArvdJc5h0ud1ONmlFs5IrVDwg/uKW4="; + goVendorHash = "sha256-UbE22AXaeUHZ9Y696oamvsbc7GwdeGqX3j+xOoFoo3g="; } diff --git a/pkg/ipasn/ipasn.go b/pkg/ipasn/ipasn.go index a26b578..08f6def 100644 --- a/pkg/ipasn/ipasn.go +++ b/pkg/ipasn/ipasn.go @@ -22,18 +22,43 @@ import ( "io" "net/netip" "os" + "sync" "sync/atomic" + "time" "github.com/gaissmai/bart" "github.com/parquet-go/parquet-go" ) +// ErrNoPrefixes is returned when an artifact opens and reads cleanly but yields +// no usable prefix at all (zero rows, or every prefix unparseable). Such a +// table would silently turn every lookup into a miss, so it is refused and the +// table already in service is kept. +var ErrNoPrefixes = errors.New("ipasn: artifact contains no usable prefixes") + // Attr is the data attached to a matched prefix. type Attr struct { ASN uint32 NetworkOwner string } +// Stats describes the table in service, for operational visibility (the +// daemon publishes these as Prometheus gauges/summaries). The zero value means +// nothing has loaded yet. +type Stats struct { + // Prefixes is the number of prefixes in the trie (same as Len). + Prefixes int + // LoadedAt is the wall-clock time of the last successful load. + LoadedAt time.Time + // BuildDuration is how long the last successful load took to read the + // artifact and build the trie (excludes waiting for the reload lock). + BuildDuration time.Duration + // ArtifactBytes and ArtifactModTime are the size and mtime of the artifact + // file the table was built from, as stat'ed at load time. + ArtifactBytes int64 + ArtifactModTime time.Time +} + // row is the subset of the collector's Parquet schema this package reads. // Field tags match internal/ipfeed/model.Record so parquet-go projects just // these columns; keeping it local avoids coupling to the collector's model. @@ -44,9 +69,22 @@ type row struct { } // Index is a concurrency-safe IP->Attr lookup backed by an atomically-swapped -// trie. The zero value is not usable; construct with New. +// trie. The zero value is usable: Lookup misses until the first successful +// Reload / ReloadIfChanged, which is what lets the daemon arm a periodic +// reload before the artifact exists. New is a convenience that loads +// immediately. type Index struct { tbl atomic.Pointer[bart.Table[Attr]] + + // mu serialises reloads and guards the loaded* bookkeeping below, which + // ReloadIfChanged compares against the file's current stat to skip + // rebuilding a trie from an unchanged artifact. + mu sync.Mutex + loadedMod time.Time + loadedSize int64 + loadedCount int + loadedAt time.Time + buildDur time.Duration } // New builds an Index from the Parquet artifact at path. @@ -62,12 +100,71 @@ func New(path string) (*Index, error) { // current table is left untouched, so a bad refresh never degrades a good // table already in service. func (ix *Index) Reload(path string) error { - t, err := build(path) + ix.mu.Lock() + defer ix.mu.Unlock() + _, err := ix.reloadLocked(path, true) + return err +} + +// ReloadIfChanged is Reload that first stats path and skips the rebuild when +// the file's size and mtime match the artifact currently in service. It +// returns reloaded=true when a new table was swapped in. A missing or +// unreadable file is an error (the current table is kept); a zero Index always +// loads. +func (ix *Index) ReloadIfChanged(path string) (reloaded bool, err error) { + ix.mu.Lock() + defer ix.mu.Unlock() + return ix.reloadLocked(path, false) +} + +// Len reports how many prefixes the table in service holds (0 before the first +// successful load). +func (ix *Index) Len() int { + ix.mu.Lock() + defer ix.mu.Unlock() + return ix.loadedCount +} + +// Stats reports the table in service (zero Stats before the first successful +// load). A failed or skipped reload leaves it untouched, so it always describes +// the table Lookup is answering from. +func (ix *Index) Stats() Stats { + ix.mu.Lock() + defer ix.mu.Unlock() + return Stats{ + Prefixes: ix.loadedCount, + LoadedAt: ix.loadedAt, + BuildDuration: ix.buildDur, + ArtifactBytes: ix.loadedSize, + ArtifactModTime: ix.loadedMod, + } +} + +// reloadLocked does the stat + build + swap. Callers hold ix.mu. The stat is +// taken before the build so a file replaced mid-read is noticed (and reloaded +// again) on the next call rather than mistaken for current. +func (ix *Index) reloadLocked(path string, force bool) (bool, error) { + info, err := os.Stat(path) + if err != nil { + return false, err + } + if !force && ix.tbl.Load() != nil && + info.Size() == ix.loadedSize && info.ModTime().Equal(ix.loadedMod) { + return false, nil + } + + start := time.Now() + t, n, err := build(path) if err != nil { - return err + return false, err } ix.tbl.Store(t) - return nil + ix.loadedMod = info.ModTime() + ix.loadedSize = info.Size() + ix.loadedCount = n + ix.buildDur = time.Since(start) + ix.loadedAt = time.Now() + return true, nil } // Lookup returns the Attr of the longest prefix matching addr. The bool is @@ -81,29 +178,33 @@ func (ix *Index) Lookup(addr netip.Addr) (Attr, bool) { return t.Lookup(addr.Unmap()) } -// build reads the Parquet artifact at path and constructs the trie. Later -// inserts for an identical prefix win (feeds may classify one prefix under -// several owners; we keep the representative value seen last). -func build(path string) (*bart.Table[Attr], error) { +// build reads the Parquet artifact at path and constructs the trie, returning +// it with the number of prefixes inserted. Later inserts for an identical +// prefix win (feeds may classify one prefix under several owners; we keep the +// representative value seen last). Rows whose prefix does not parse are +// skipped; an artifact that yields no prefix at all is ErrNoPrefixes. Any read +// error other than io.EOF is returned — it is never mistaken for end-of-file. +func build(path string) (*bart.Table[Attr], int, error) { f, err := os.Open(path) if err != nil { - return nil, err + return nil, 0, err } defer f.Close() info, err := f.Stat() if err != nil { - return nil, err + return nil, 0, err } pf, err := parquet.OpenFile(f, info.Size()) if err != nil { - return nil, fmt.Errorf("ipasn: open parquet %s: %w", path, err) + return nil, 0, fmt.Errorf("ipasn: open parquet %s: %w", path, err) } reader := parquet.NewGenericReader[row](pf) defer reader.Close() //nolint:errcheck // read-only reader; close error is not actionable t := new(bart.Table[Attr]) + inserted := 0 buf := make([]row, 1024) for { n, err := reader.Read(buf) @@ -112,15 +213,21 @@ func build(path string) (*bart.Table[Attr], error) { if perr != nil { continue // artifact is collector-canonicalized; skip any stray row } - t.Insert(pfx, Attr{ASN: buf[i].ASN, NetworkOwner: buf[i].NetworkOwner}) + t.Insert(pfx.Masked(), Attr{ASN: buf[i].ASN, NetworkOwner: buf[i].NetworkOwner}) + inserted++ } if err != nil { - // io.EOF (as parquet-go returns it) means we've read the last batch. - if n == 0 || errors.Is(err, io.EOF) { - break + if errors.Is(err, io.EOF) { + break // parquet-go signals the last batch with io.EOF } - return nil, fmt.Errorf("ipasn: read parquet %s: %w", path, err) + return nil, 0, fmt.Errorf("ipasn: read parquet %s: %w", path, err) } + if n == 0 { + break // defensive: a reader that returns (0, nil) has nothing more + } + } + if inserted == 0 { + return nil, 0, fmt.Errorf("%w: %s", ErrNoPrefixes, path) } - return t, nil + return t, inserted, nil } diff --git a/pkg/ipasn/ipasn_test.go b/pkg/ipasn/ipasn_test.go index f70f718..0f2e413 100644 --- a/pkg/ipasn/ipasn_test.go +++ b/pkg/ipasn/ipasn_test.go @@ -1,13 +1,19 @@ package ipasn import ( + "errors" + "fmt" "net/netip" "os" "path/filepath" "sync" "testing" + "time" "github.com/parquet-go/parquet-go" + + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/output" ) // writeArtifact writes rows to a temp Parquet file and returns its path. @@ -19,8 +25,10 @@ func writeArtifact(t testing.TB, rows []row) string { t.Fatalf("create: %v", err) } w := parquet.NewGenericWriter[row](f) - if _, err := w.Write(rows); err != nil { - t.Fatalf("write: %v", err) + if len(rows) > 0 { + if _, err := w.Write(rows); err != nil { + t.Fatalf("write: %v", err) + } } if err := w.Close(); err != nil { t.Fatalf("close writer: %v", err) @@ -77,26 +85,450 @@ func TestLookup(t *testing.T) { } } -// TestLookupBeforeLoad verifies a zero table (nil pointer) is a safe miss. -func TestLookupBeforeLoad(t *testing.T) { - var ix Index // zero value, never Reloaded - if _, ok := ix.Lookup(netip.MustParseAddr("1.1.1.1")); ok { - t.Error("boundary: lookup on an unloaded Index should be a miss") +// TestReloadKeepsTable covers the load/refresh contract: a zero Index is a safe +// miss, a failed Reload never degrades the table in service, and every kind of +// bad artifact is refused with the right error. +// +// go test ./pkg/ipasn/ -run TestReloadKeepsTable +func TestReloadKeepsTable(t *testing.T) { + tests := []struct { + description string + preload bool // load fixtureRows first + path func(t *testing.T) string // artifact to Reload + wantErr error // errors.Is target; nil = success; errAny = any error + wantHit bool // 1.1.1.5 resolves afterwards + wantLen int // Len() afterwards + }{ + // positive + {"reload of a good artifact over a good table swaps it in", true, + func(t *testing.T) string { + return writeArtifact(t, []row{{Prefix: "1.1.1.0/24", ASN: 1, NetworkOwner: "new"}}) + }, nil, true, 1}, + {"zero Index loads on first Reload", false, + func(t *testing.T) string { return writeArtifact(t, fixtureRows) }, nil, true, 5}, + // negative + {"zero Index, no load -> lookup misses, Len 0", false, nil, nil, false, 0}, + {"missing file keeps the good table", true, + func(*testing.T) string { return "/nonexistent/feeds.parquet" }, os.ErrNotExist, true, 5}, + {"corrupt (non-parquet) file keeps the good table", true, + func(t *testing.T) string { return writeBytes(t, []byte("this is not a parquet file")) }, errAny, true, 5}, + {"zero-row artifact is refused (ErrNoPrefixes), good table kept", true, + func(t *testing.T) string { return writeArtifact(t, nil) }, ErrNoPrefixes, true, 5}, + {"artifact whose every prefix is unparseable is refused", true, + func(t *testing.T) string { return writeArtifact(t, []row{{Prefix: "not-a-prefix"}, {Prefix: ""}}) }, ErrNoPrefixes, true, 5}, + {"zero Index + bad artifact -> still a miss, Len 0", false, + func(t *testing.T) string { return writeArtifact(t, nil) }, ErrNoPrefixes, false, 0}, + // boundary / corner + {"empty (0-byte) file keeps the good table", true, + func(t *testing.T) string { return writeBytes(t, nil) }, errAny, true, 5}, + {"directory instead of file keeps the good table", true, + func(t *testing.T) string { return t.TempDir() }, errAny, true, 5}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var ix Index + if tc.preload { + if err := ix.Reload(writeArtifact(t, fixtureRows)); err != nil { + t.Fatalf("preload: %v", err) + } + } + if tc.path != nil { + err := ix.Reload(tc.path(t)) + switch { + case tc.wantErr == nil && err != nil: + t.Errorf("Reload err = %v, want nil", err) + case tc.wantErr == errAny && err == nil: + t.Errorf("Reload err = nil, want an error") + case tc.wantErr != nil && tc.wantErr != errAny && !errors.Is(err, tc.wantErr): + t.Errorf("Reload err = %v, want errors.Is(%v)", err, tc.wantErr) + } + } + got, ok := ix.Lookup(netip.MustParseAddr("1.1.1.5")) + if ok != tc.wantHit { + t.Errorf("Lookup(1.1.1.5) ok = %v (%+v), want %v", ok, got, tc.wantHit) + } + if n := ix.Len(); n != tc.wantLen { + t.Errorf("Len() = %d, want %d", n, tc.wantLen) + } + }) } } -// TestReloadBadPath verifies a failed Reload leaves the existing table intact. -func TestReloadBadPath(t *testing.T) { - ix, err := New(writeArtifact(t, fixtureRows)) +// errAny is a sentinel for "any non-nil error" in the tables above. +var errAny = errors.New("any error") + +// writeBytes writes raw bytes to a temp file and returns its path. +func writeBytes(t testing.TB, b []byte) string { + t.Helper() + path := filepath.Join(t.TempDir(), "raw.parquet") + if err := os.WriteFile(path, b, 0o600); err != nil { + t.Fatalf("write: %v", err) + } + return path +} + +// TestBuildRows covers what build does with individual rows: skipping strays, +// last-wins on duplicates, host-bit canonicalisation, and the count returned. +// +// go test ./pkg/ipasn/ -run TestBuildRows +func TestBuildRows(t *testing.T) { + tests := []struct { + description string + rows []row + wantLen int + probes map[string]Attr // addr -> expected Attr (zero Attr = miss) + }{ + // positive + {"two disjoint prefixes both inserted", []row{{"1.1.1.0/24", 1, "a"}, {"2.2.2.0/24", 2, "b"}}, 2, + map[string]Attr{"1.1.1.1": {1, "a"}, "2.2.2.2": {2, "b"}, "3.3.3.3": {}}}, + // corner + {"unparseable prefix is skipped, the valid one is kept and counted", []row{{"garbage", 9, "x"}, {"1.1.1.0/24", 1, "a"}}, 1, + map[string]Attr{"1.1.1.1": {1, "a"}}}, + {"duplicate prefix: last row wins", []row{{"1.1.1.0/24", 1, "first"}, {"1.1.1.0/24", 2, "second"}}, 2, + map[string]Attr{"1.1.1.1": {2, "second"}}}, + {"prefix with host bits set is masked (1.1.1.7/24 == 1.1.1.0/24)", []row{{"1.1.1.7/24", 1, "a"}}, 1, + map[string]Attr{"1.1.1.200": {1, "a"}}}, + {"same prefix spelled with and without host bits collapses to one entry, last wins", + []row{{"1.1.1.0/24", 1, "a"}, {"1.1.1.9/24", 2, "b"}}, 2, + map[string]Attr{"1.1.1.1": {2, "b"}}}, + // boundary + {"/0 default prefix matches everything", []row{{"0.0.0.0/0", 7, "world"}}, 1, + map[string]Attr{"203.0.113.9": {7, "world"}}}, + {"/32 host prefix matches only itself", []row{{"1.1.1.1/32", 1, "host"}}, 1, + map[string]Attr{"1.1.1.1": {1, "host"}, "1.1.1.2": {}}}, + {"more than one read batch (1500 rows > 1024 buffer) all inserted", manyRows(1500), 1500, + map[string]Attr{"10.0.0.1": {0, "r0"}, "10.5.219.1": {1499, "r1499"}}}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + tbl, n, err := build(writeArtifact(t, tc.rows)) + if err != nil { + t.Fatalf("build: %v", err) + } + if n != tc.wantLen { + t.Errorf("inserted = %d, want %d", n, tc.wantLen) + } + for addr, want := range tc.probes { + got, ok := tbl.Lookup(netip.MustParseAddr(addr)) + if want == (Attr{}) { + if ok { + t.Errorf("Lookup(%s) = %+v, want miss", addr, got) + } + continue + } + if !ok || got != want { + t.Errorf("Lookup(%s) = (%+v,%v), want %+v", addr, got, ok, want) + } + } + }) + } +} + +// manyRows yields n distinct /24s under 10.0.0.0/8 (10.a.b.0/24, a=i/256, b=i%256). +func manyRows(n int) []row { + out := make([]row, 0, n) + for i := range n { + out = append(out, row{Prefix: fmt.Sprintf("10.%d.%d.0/24", i/256, i%256), ASN: uint32(i), NetworkOwner: fmt.Sprintf("r%d", i)}) + } + return out +} + +// TestCollectorSchemaArtifact loads a file written with the collector's full +// model.Record schema (17 columns) through the collector's own WriteParquet, +// proving the 3-column projection in row stays compatible with the producer. +// +// go test ./pkg/ipasn/ -run TestCollectorSchemaArtifact +func TestCollectorSchemaArtifact(t *testing.T) { + tests := []struct { + description string + records []model.Record + wantErr error + probes map[string]Attr + }{ + // positive + {"full-schema rows load; only prefix/asn/network_owner are read", + []model.Record{ + {Prefix: "1.1.1.0/24", IPVersion: 4, ASN: 13335, NetworkOwner: "cloudflare", Provider: "Cloudflare", Service: "cdn", SourceName: "cloudflare-v4"}, + {Prefix: "2606:4700::/32", IPVersion: 6, ASN: 13335, NetworkOwner: "cloudflare"}, + }, nil, + map[string]Attr{"1.1.1.1": {13335, "cloudflare"}, "2606:4700::1": {13335, "cloudflare"}}}, + // corner + {"ASN 0 (owner without a known ASN) is a hit with ASN 0", + []model.Record{{Prefix: "9.9.9.0/24", IPVersion: 4, ASN: 0, NetworkOwner: "quad9-unknown"}}, nil, + map[string]Attr{"9.9.9.9": {0, "quad9-unknown"}}}, + // negative + {"collector artifact with zero records is refused", nil, ErrNoPrefixes, nil}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + path := filepath.Join(t.TempDir(), "feeds.parquet") + if _, err := output.WriteParquet(path, tc.records); err != nil { + t.Fatalf("WriteParquet: %v", err) + } + ix, err := New(path) + if tc.wantErr != nil { + if !errors.Is(err, tc.wantErr) { + t.Fatalf("New err = %v, want errors.Is(%v)", err, tc.wantErr) + } + return + } + if err != nil { + t.Fatalf("New: %v", err) + } + for addr, want := range tc.probes { + got, ok := ix.Lookup(netip.MustParseAddr(addr)) + if !ok || got != want { + t.Errorf("Lookup(%s) = (%+v,%v), want %+v", addr, got, ok, want) + } + } + }) + } +} + +// TestReloadIfChanged covers the stat-based skip: unchanged file -> no rebuild; +// changed size or mtime -> rebuild; errors keep the table. +// +// go test ./pkg/ipasn/ -run TestReloadIfChanged +func TestReloadIfChanged(t *testing.T) { + past := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + tests := []struct { + description string + mutate func(t *testing.T, path string) string // returns the path to reload from + wantReloaded bool + wantErr bool + wantOwner string // owner of 1.1.1.5 afterwards + }{ + // positive + {"same file, untouched -> not reloaded", func(_ *testing.T, p string) string { return p }, false, false, "cloudflare"}, + {"rewritten with different content (size changes) -> reloaded", + func(t *testing.T, p string) string { + rewrite(t, p, []row{{Prefix: "1.1.1.0/24", ASN: 1, NetworkOwner: "changed-owner-longer-name"}}) + return p + }, true, false, "changed-owner-longer-name"}, + {"same size but newer mtime -> reloaded", + func(t *testing.T, p string) string { + rewrite(t, p, []row{{Prefix: "1.1.1.0/24", ASN: 13335, NetworkOwner: "cloudflarX"}}) + // force a distinct mtime regardless of filesystem timestamp granularity + if err := os.Chtimes(p, past.Add(time.Hour), past.Add(time.Hour)); err != nil { + t.Fatal(err) + } + return p + }, true, false, "cloudflarX"}, + // negative + {"file removed -> error, table kept", func(t *testing.T, p string) string { + if err := os.Remove(p); err != nil { + t.Fatal(err) + } + return p + }, false, true, "cloudflare"}, + {"file replaced by an empty artifact -> ErrNoPrefixes, table kept", func(t *testing.T, p string) string { + rewrite(t, p, nil) + return p + }, false, true, "cloudflare"}, + // corner + {"different path with identical stat is still loaded (path is not part of the key, content wins)", + func(t *testing.T, p string) string { + other := filepath.Join(filepath.Dir(p), "other.parquet") + rewrite(t, other, []row{{Prefix: "1.1.1.0/24", ASN: 2, NetworkOwner: "other"}}) + return other + }, true, false, "other"}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + path := writeArtifact(t, fixtureRows) + if err := os.Chtimes(path, past, past); err != nil { + t.Fatal(err) + } + var ix Index + if reloaded, err := ix.ReloadIfChanged(path); err != nil || !reloaded { + t.Fatalf("first ReloadIfChanged = (%v,%v), want (true,nil)", reloaded, err) + } + + target := tc.mutate(t, path) + reloaded, err := ix.ReloadIfChanged(target) + if (err != nil) != tc.wantErr { + t.Errorf("err = %v, wantErr %v", err, tc.wantErr) + } + if reloaded != tc.wantReloaded { + t.Errorf("reloaded = %v, want %v", reloaded, tc.wantReloaded) + } + got, ok := ix.Lookup(netip.MustParseAddr("1.1.1.5")) + if !ok || got.NetworkOwner != tc.wantOwner { + t.Errorf("Lookup(1.1.1.5) = (%+v,%v), want owner %q", got, ok, tc.wantOwner) + } + }) + } +} + +// rewrite replaces the artifact at path with rows (same writer as writeArtifact). +func rewrite(t *testing.T, path string, rows []row) { + t.Helper() + f, err := os.Create(path) if err != nil { - t.Fatalf("New: %v", err) + t.Fatal(err) } - if err := ix.Reload("/nonexistent/feeds.parquet"); err == nil { - t.Fatal("negative: Reload of a missing file should error") + w := parquet.NewGenericWriter[row](f) + if len(rows) > 0 { + if _, err := w.Write(rows); err != nil { + t.Fatal(err) + } + } + if err := w.Close(); err != nil { + t.Fatal(err) + } + if err := f.Close(); err != nil { + t.Fatal(err) + } +} + +// TestStats covers the operational-visibility snapshot: zero before any load, +// populated by a successful load, and left describing the table in service +// after a failed or skipped reload. +// +// go test ./pkg/ipasn/ -run TestStats +func TestStats(t *testing.T) { + past := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + tests := []struct { + description string + // steps runs against a zero Index; the path of the fixture artifact is + // passed in. It returns the Stats taken before the final step so rows + // can assert what did or did not change. + steps func(t *testing.T, ix *Index, path string) (before Stats) + wantPrefixes int + wantLoaded bool // LoadedAt / BuildDuration / ArtifactBytes populated + wantModTime time.Time + // compare, when set, is called with (before, after) for row-specific checks. + compare func(t *testing.T, before, after Stats) + }{ + // boundary — nothing loaded + {"zero Index reports the zero Stats", + func(*testing.T, *Index, string) Stats { return Stats{} }, 0, false, time.Time{}, nil}, + // positive + {"successful load populates every field from the artifact", + func(t *testing.T, ix *Index, path string) Stats { + if err := ix.Reload(path); err != nil { + t.Fatal(err) + } + return Stats{} + }, len(fixtureRows), true, past, nil}, + {"reload of a smaller artifact updates the count and the load time", + func(t *testing.T, ix *Index, path string) Stats { + if err := ix.Reload(path); err != nil { + t.Fatal(err) + } + before := ix.Stats() + time.Sleep(2 * time.Millisecond) // make LoadedAt distinguishable + rewrite(t, path, []row{{Prefix: "1.1.1.0/24", ASN: 1, NetworkOwner: "one"}}) + if err := ix.Reload(path); err != nil { + t.Fatal(err) + } + return before + }, 1, true, time.Time{}, + func(t *testing.T, before, after Stats) { + if !after.LoadedAt.After(before.LoadedAt) { + t.Errorf("LoadedAt not advanced: before %v after %v", before.LoadedAt, after.LoadedAt) + } + if after.ArtifactBytes == before.ArtifactBytes { + t.Errorf("ArtifactBytes unchanged (%d) although the artifact was rewritten", after.ArtifactBytes) + } + }}, + // negative — failure keeps the previous snapshot + {"failed reload (missing file) leaves Stats describing the table in service", + func(t *testing.T, ix *Index, path string) Stats { + if err := ix.Reload(path); err != nil { + t.Fatal(err) + } + before := ix.Stats() + if err := ix.Reload(filepath.Join(filepath.Dir(path), "missing.parquet")); err == nil { + t.Fatal("Reload of a missing file succeeded") + } + return before + }, len(fixtureRows), true, past, + func(t *testing.T, before, after Stats) { + if before != after { + t.Errorf("Stats changed across a failed reload:\n before %+v\n after %+v", before, after) + } + }}, + {"failed reload (zero-row artifact) leaves Stats untouched", + func(t *testing.T, ix *Index, path string) Stats { + if err := ix.Reload(path); err != nil { + t.Fatal(err) + } + before := ix.Stats() + other := filepath.Join(filepath.Dir(path), "empty.parquet") + rewrite(t, other, nil) + if err := ix.Reload(other); !errors.Is(err, ErrNoPrefixes) { + t.Fatalf("Reload err = %v, want ErrNoPrefixes", err) + } + return before + }, len(fixtureRows), true, past, + func(t *testing.T, before, after Stats) { + if before != after { + t.Errorf("Stats changed across a failed reload:\n before %+v\n after %+v", before, after) + } + }}, + {"zero Index + failed load stays at the zero Stats", + func(t *testing.T, ix *Index, path string) Stats { + if err := ix.Reload(filepath.Join(filepath.Dir(path), "missing.parquet")); err == nil { + t.Fatal("Reload of a missing file succeeded") + } + return Stats{} + }, 0, false, time.Time{}, nil}, + // corner — skipped reload is not a load + {"ReloadIfChanged on an unchanged file leaves LoadedAt and BuildDuration as they were", + func(t *testing.T, ix *Index, path string) Stats { + if _, err := ix.ReloadIfChanged(path); err != nil { + t.Fatal(err) + } + before := ix.Stats() + time.Sleep(2 * time.Millisecond) + if reloaded, err := ix.ReloadIfChanged(path); err != nil || reloaded { + t.Fatalf("second ReloadIfChanged = (%v,%v), want (false,nil)", reloaded, err) + } + return before + }, len(fixtureRows), true, past, + func(t *testing.T, before, after Stats) { + if before != after { + t.Errorf("Stats changed across a skipped reload:\n before %+v\n after %+v", before, after) + } + }}, } - // The good table must still answer. - if got, ok := ix.Lookup(netip.MustParseAddr("1.1.1.5")); !ok || got.ASN != 13335 { - t.Errorf("corner: table degraded after a failed Reload: got (%+v,%v)", got, ok) + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + path := writeArtifact(t, fixtureRows) + if err := os.Chtimes(path, past, past); err != nil { + t.Fatal(err) + } + var ix Index + before := tc.steps(t, &ix, path) + got := ix.Stats() + + if got.Prefixes != tc.wantPrefixes { + t.Errorf("Prefixes = %d, want %d", got.Prefixes, tc.wantPrefixes) + } + if got.Prefixes != ix.Len() { + t.Errorf("Prefixes (%d) disagrees with Len() (%d)", got.Prefixes, ix.Len()) + } + if tc.wantLoaded { + if got.LoadedAt.IsZero() { + t.Error("LoadedAt is zero after a successful load") + } + if got.BuildDuration <= 0 { + t.Errorf("BuildDuration = %v, want > 0", got.BuildDuration) + } + if got.ArtifactBytes <= 0 { + t.Errorf("ArtifactBytes = %d, want > 0", got.ArtifactBytes) + } + } else if got != (Stats{}) { + t.Errorf("Stats = %+v, want zero value", got) + } + if !tc.wantModTime.IsZero() && !got.ArtifactModTime.Equal(tc.wantModTime) { + t.Errorf("ArtifactModTime = %v, want %v", got.ArtifactModTime, tc.wantModTime) + } + if tc.compare != nil { + tc.compare(t, before, got) + } + }) } } diff --git a/pkg/localnet/localnet.go b/pkg/localnet/localnet.go index 03f13d8..b2b4ca4 100644 --- a/pkg/localnet/localnet.go +++ b/pkg/localnet/localnet.go @@ -1,14 +1,14 @@ // Package localnet classifies a socket endpoint IP as belonging to the local -// host (self), a directly-connected subnet, or somewhere remote, using the +// host (self), a directly-connected local subnet, or somewhere remote, using the // local addresses and routing table of a specific network namespace. // // It is the consumer side of the rtnetlink discovery machinery in pkg/xtcpnl: // xtcp2 dumps each monitored namespace's RTM_GETADDR + RTM_GETROUTE (and // RTM_GETLINK) replies, feeds the parsed AddrInfo/RouteInfo into BuildSnapshot, // and publishes the immutable Snapshot atomically. On xtcp2's per-socket -// enrichment hot path a destination address is classified with Classify before -// the internet IP->ASN lookup: self and connected-subnet destinations never -// reach the ASN feed. +// enrichment hot path a destination address is classified with Resolve before +// the internet IP->ASN lookup: self and local-subnet destinations never reach +// the ASN feed. // // A Snapshot is built once (off the hot path) and never mutated; Classify is a // pure, allocation-free, lock-free read, mirroring pkg/ipasn's contract. @@ -49,7 +49,7 @@ func (l Locality) String() string { case LocalitySelf: return "self" case LocalitySubnet: - return "connected_subnet" + return "local_subnet" case LocalityRemote: return "remote" default: @@ -57,84 +57,275 @@ func (l Locality) String() string { } } -// Snapshot is an immutable per-namespace view of local addresses and connected -// subnets. Self addresses are stored as host prefixes (/32, /128) and connected -// subnets as their network prefix in a single longest-prefix-match trie, so a -// self host address wins over its containing subnet in one Lookup. The zero -// value classifies everything as remote; build with BuildSnapshot. +// routeEntry is the value stored per prefix in the trie: how a destination in +// that prefix is classified, plus the egress interface index of the route it +// came from (0 when unknown, e.g. for self addresses without an owning route). +type routeEntry struct { + loc Locality + oif uint32 // egress interface index (route Oif / address ifindex) +} + +// Snapshot is an immutable per-namespace view of local addresses, connected +// subnets and the routing table. Self addresses are stored as host prefixes +// (/32, /128), connected subnets as their network prefix, and gateway routes +// (including the default route) as their prefix — all in a single +// longest-prefix-match trie keyed to a routeEntry, so a self host address wins +// over its containing subnet and the most-specific route supplies the egress +// interface in one Lookup. ifnames resolves an interface index (the route's Oif +// or a socket's kernel idiag_if) to a human name from the RTM_GETLINK dump. The +// zero value classifies everything as remote; build with BuildSnapshot. type Snapshot struct { - tbl *bart.Table[Locality] + tbl *bart.Table[routeEntry] + ifnames map[uint32]string + // nonLoopbackSelf records that at least one self entry (an interface + // address or an RTN_LOCAL route) lies outside 127.0.0.0/8 and ::1. A + // namespace with only loopback is usually one whose veth has not been + // plumbed yet (container start-up race), so the daemon re-dumps it on the + // next reconcile instead of waiting a full refresh interval. + nonLoopbackSelf bool +} + +// HasNonLoopbackSelf reports whether the snapshot saw any self address beyond +// loopback. false means the namespace looked freshly created (lo only) at dump +// time and is worth re-dumping soon. The zero and nil Snapshot report false. +func (s *Snapshot) HasNonLoopbackSelf() bool { + return s != nil && s.nonLoopbackSelf } -// Classify returns how addr relates to this snapshot's namespace. Loopback and -// the unspecified address short-circuit to self; a valid non-self address that -// matches a connected subnet is LocalitySubnet; anything else is LocalityRemote. -// An invalid address is LocalityUnspecified. Pure and allocation-free. +// Classify returns how addr relates to this snapshot's namespace. Loopback +// short-circuits to self; the unspecified address (no destination, e.g. a LISTEN +// socket's peer) and an invalid address are LocalityUnspecified; a valid address +// that matches a connected subnet is LocalitySubnet; anything else is +// LocalityRemote. Pure and allocation-free. func (s *Snapshot) Classify(addr netip.Addr) Locality { + loc, _, _ := s.Lookup(addr) + return loc +} + +// Lookup is the richer form of Classify used on the enrichment hot path: it +// returns the destination's Locality, the egress interface index of the route it +// longest-prefix matches (0 when unknown), and ok=false only for an invalid +// address. The unspecified address (0.0.0.0 / ::) is LocalityUnspecified with no +// egress: it is not a destination. Loopback is always self; its egress is the +// loopback route's Oif when the snapshot has a self entry covering it (the +// kernel's `local 127.0.0.0/8 dev lo` / `local ::1 dev lo`), and 0 otherwise — +// never the egress of a covering gateway/default route, which loopback traffic +// does not use. Pure and allocation-free. +func (s *Snapshot) Lookup(addr netip.Addr) (loc Locality, egressIfindex uint32, ok bool) { a := addr.Unmap() if !a.IsValid() { - return LocalityUnspecified + return LocalityUnspecified, 0, false } - if a.IsLoopback() || a.IsUnspecified() { - return LocalitySelf + if a.IsUnspecified() { + return LocalityUnspecified, 0, true } - if s == nil || s.tbl == nil { - return LocalityRemote + loopback := a.IsLoopback() + if s != nil && s.tbl != nil { + if e, found := s.tbl.Lookup(a); found { + if loopback { + if e.loc != LocalitySelf { + return LocalitySelf, 0, true + } + return LocalitySelf, e.oif, true + } + return e.loc, e.oif, true + } } - if v, ok := s.tbl.Lookup(a); ok { - return v + if loopback { + return LocalitySelf, 0, true } - return LocalityRemote + return LocalityRemote, 0, true } -// BuildSnapshot constructs a Snapshot from one namespace's parsed RTM_GETADDR -// and RTM_GETROUTE replies. Self set = every interface address (IFA_LOCAL, -// falling back to IFA_ADDRESS) plus every RTN_LOCAL route destination. -// Connected subnets = routes that are unicast, gatewayless and carry a -// destination prefix (scope is NOT part of the test — IPv4 connected subnets -// are scope-link but IPv6 connected subnets are scope-universe). It is pure: -// no syscalls, safe to feed test fixtures. -func BuildSnapshot(addrs []xtcpnl.AddrInfo, routes []xtcpnl.RouteInfo) *Snapshot { - tbl := new(bart.Table[Locality]) +// IfName resolves an interface index (a route's egress Oif or a socket's kernel +// idiag_if) to its name from this namespace's RTM_GETLINK dump, or "" when the +// index is 0 or unknown. Pure and allocation-free. +func (s *Snapshot) IfName(index uint32) string { + if s == nil || index == 0 { + return "" + } + return s.ifnames[index] +} +// Resolution is the alloc-free result of classifying one destination against a +// snapshot: the destination's Locality, its egress interface (the matched route's +// Oif, as index and resolved name), the resolved name of the socket's own bound +// interface (the kernel idiag_if), and whether the destination is remote (the +// only class that should fall through to the internet IP->ASN lookup). +type Resolution struct { + Locality Locality + EgressIfindex uint32 + EgressIfname string + BoundIfname string + // Remote is false for self, local-subnet and unspecified destinations (skip + // the ASN feed) and true for LocalityRemote — including the no-match case, + // where a non-self destination falls through to LocalityRemote and the ASN + // lookup runs exactly as before locality enrichment existed. + Remote bool +} + +// Resolve folds the enrichment hot path's per-socket interface/locality work into +// one call: it looks up dst's locality + egress interface, resolves both the +// egress Oif and the socket's bound interface index (the kernel idiag_if) to +// names, and reports whether the destination is remote. A no-match destination +// resolves to LocalityRemote with empty names, matching the pre-locality path. +// Pure and allocation-free. +func (s *Snapshot) Resolve(dst netip.Addr, boundIfindex uint32) Resolution { + loc, egressIf, _ := s.Lookup(dst) + return Resolution{ + Locality: loc, + EgressIfindex: egressIf, + EgressIfname: s.IfName(egressIf), + BoundIfname: s.IfName(boundIfindex), + Remote: loc == LocalityRemote, + } +} + +// BuildSnapshot constructs a Snapshot from one namespace's parsed RTM_GETADDR, +// RTM_GETROUTE and RTM_GETLINK replies. Only routes in the main and local +// tables are considered (see inClassifiedTable). Self set = every interface +// address (IFA_LOCAL, falling back to IFA_ADDRESS) plus every RTN_LOCAL route +// prefix (host routes, and ranges such as `local 127.0.0.0/8 dev lo`). Connected +// subnets = unicast routes that carry a destination prefix and are delivered +// on-link — no RTA_GATEWAY, RTA_VIA, RTA_MULTIPATH or RTA_NH_ID (scope is NOT +// part of the test — IPv4 connected subnets are scope-link but IPv6 connected +// subnets are scope-universe). Every other unicast route (gateway, default, +// multipath, nexthop-object) is recorded as LocalityRemote so the longest-prefix +// match still yields its egress interface where one is known. A self entry is +// never overwritten by a same-prefix route, whatever order the dumps arrive in. +// links maps an interface index to its name (RTM_GETLINK) for resolving the +// egress Oif and a socket's kernel idiag_if. It is pure: no syscalls, safe to +// feed test fixtures. +func BuildSnapshot(addrs []xtcpnl.AddrInfo, routes []xtcpnl.RouteInfo, links map[uint32]string) *Snapshot { + tbl := new(bart.Table[routeEntry]) + + ifnames := make(map[uint32]string, len(links)) + for idx, name := range links { + ifnames[idx] = name + } + + nonLoopbackSelf := false for _, ai := range addrs { raw := ai.Local if len(raw) == 0 { raw = ai.Address } if a, ok := addrFromBytes(raw); ok { - tbl.Insert(hostPrefix(a), LocalitySelf) + tbl.Insert(hostPrefix(a), routeEntry{loc: LocalitySelf, oif: ai.Index}) + if !a.IsLoopback() { + nonLoopbackSelf = true + } } } for _, ri := range routes { - switch { - case ri.Type == unix.RTN_LOCAL: - // A locally-attached address (usually in RT_TABLE_LOCAL, scope host). - if a, ok := addrFromBytes(ri.Dst); ok { - tbl.Insert(hostPrefix(a), LocalitySelf) - } - case ri.Type == unix.RTN_UNICAST && - len(ri.Gateway) == 0 && - len(ri.Dst) > 0: - // A directly-connected subnet (one L2 hop, no next-hop router). - // The distinguishing signal is unicast + a destination prefix + no - // gateway, NOT the route scope: real captures show IPv4 connected - // subnets carry scope=RT_SCOPE_LINK (253) while IPv6 connected - // subnets carry scope=RT_SCOPE_UNIVERSE (0), so gating on - // RT_SCOPE_LINK silently misclassifies every IPv6 on-link subnet as - // REMOTE. + if !inClassifiedTable(ri.Table) { + continue + } + switch ri.Type { + case unix.RTN_LOCAL: + // A locally-attached address (RT_TABLE_LOCAL, scope host). Usually a + // host route, but the kernel also installs `local 127.0.0.0/8 dev lo`: + // honour the prefix length so the whole range is self. if pfx, ok := prefixFromBytes(ri.Dst, ri.DstLen); ok { - // Don't let a /0 connected route swallow everything into - // LocalitySubnet. - if pfx.Bits() > 0 { - tbl.Insert(pfx, LocalitySubnet) + tbl.Insert(pfx, routeEntry{loc: LocalitySelf, oif: ri.Oif}) + if !isLoopbackPrefix(pfx) { + nonLoopbackSelf = true + } + } + case unix.RTN_UNICAST: + pfx, ok := routePrefix(ri) + if !ok { + continue + } + switch { + case gatewayReached(ri): + // Reached via a next hop (includes the /0 default route): remote, + // but keep the egress interface for the LPM when the route names + // exactly one. A multipath list or a nexthop object has several / + // opaque egress interfaces, so report none rather than a wrong one. + oif := ri.Oif + if ri.HasMultipath || ri.NhID != 0 { + oif = 0 } + insertRoute(tbl, pfx, routeEntry{loc: LocalityRemote, oif: oif}) + case pfx.Bits() == 0: + // A gatewayless default route (`default dev wg0`: a point-to-point + // tunnel or PPP link). Everything not matched more specifically + // leaves via that interface, but it is not a local subnet — a /0 + // must never swallow every address into LocalitySubnet. + insertRoute(tbl, pfx, routeEntry{loc: LocalityRemote, oif: ri.Oif}) + default: + // A directly-connected subnet (one L2 hop, no next-hop router). + // The distinguishing signal is unicast + a destination prefix + no + // next hop, NOT the route scope: real captures show IPv4 connected + // subnets carry scope=RT_SCOPE_LINK (253) while IPv6 connected + // subnets carry scope=RT_SCOPE_UNIVERSE (0), so gating on + // RT_SCOPE_LINK silently misclassifies every IPv6 on-link subnet + // as REMOTE. + insertRoute(tbl, pfx, routeEntry{loc: LocalitySubnet, oif: ri.Oif}) } } } - return &Snapshot{tbl: tbl} + return &Snapshot{tbl: tbl, ifnames: ifnames, nonLoopbackSelf: nonLoopbackSelf} +} + +// isLoopbackPrefix reports whether pfx lies entirely inside the loopback +// range: 127.0.0.0/8 (any prefix at or below it) or ::1/128. Used to decide +// whether a self entry counts as real (non-loopback) connectivity. +func isLoopbackPrefix(pfx netip.Prefix) bool { + a := pfx.Addr() + if !a.IsLoopback() { + return false + } + if a.Is4() { + return pfx.Bits() >= 8 // 127.0.0.0/8 or narrower + } + return pfx.Bits() == 128 // ::1/128 only +} + +// inClassifiedTable limits classification to the tables every namespace +// consults for ordinary traffic: main (connected subnets, gateways, the default +// route) and local (the kernel's own-address entries). Policy-routing tables +// (VRFs, `ip rule` tables) describe traffic this daemon cannot attribute without +// the rule set, so their routes are ignored rather than guessed at. +func inClassifiedTable(table uint32) bool { + return table == unix.RT_TABLE_MAIN || table == unix.RT_TABLE_LOCAL +} + +// gatewayReached reports whether a unicast route hands packets to a next hop +// rather than delivering on-link: an explicit RTA_GATEWAY, a cross-family +// RTA_VIA gateway, an RTA_MULTIPATH nexthop list, or an RTA_NH_ID nexthop object +// (whose gateways live outside this message). Such a route is never a connected +// subnet even though it carries no RTA_GATEWAY of its own. +func gatewayReached(ri xtcpnl.RouteInfo) bool { + return len(ri.Gateway) > 0 || ri.HasVia || ri.HasMultipath || ri.NhID != 0 +} + +// routePrefix returns the destination prefix of a unicast route. The default +// route carries no RTA_DST (empty Dst, DstLen 0) and means the family-wide /0; +// every other unicast route has an explicit prefix. A route with a prefix length +// but no destination bytes is malformed and rejected. +func routePrefix(ri xtcpnl.RouteInfo) (netip.Prefix, bool) { + switch { + case len(ri.Dst) > 0: + return prefixFromBytes(ri.Dst, ri.DstLen) + case ri.DstLen == 0: + return defaultPrefix(ri.Family) + } + return netip.Prefix{}, false +} + +// insertRoute records a route-derived (non-self) entry unless the exact prefix +// is already a self entry: a namespace's own address must stay self whether the +// address dump or a same-prefix unicast route (e.g. `10.0.0.5/32 dev eth0`) was +// seen first. Later routes for the same prefix otherwise overwrite earlier ones. +func insertRoute(tbl *bart.Table[routeEntry], pfx netip.Prefix, e routeEntry) { + if cur, ok := tbl.Get(pfx); ok && cur.loc == LocalitySelf { + return + } + tbl.Insert(pfx, e) } // addrFromBytes converts raw network-order address bytes (4 = IPv4, 16 = IPv6) @@ -150,6 +341,18 @@ func addrFromBytes(b []byte) (netip.Addr, bool) { return a.Unmap(), true } +// defaultPrefix returns the family-wide /0 prefix for a default route, which the +// kernel emits without an RTA_DST attribute. +func defaultPrefix(family uint8) (netip.Prefix, bool) { + switch family { + case unix.AF_INET: + return netip.PrefixFrom(netip.IPv4Unspecified(), 0), true + case unix.AF_INET6: + return netip.PrefixFrom(netip.IPv6Unspecified(), 0), true + } + return netip.Prefix{}, false +} + // hostPrefix returns the /32 or /128 single-host prefix for a. func hostPrefix(a netip.Addr) netip.Prefix { return netip.PrefixFrom(a, a.BitLen()) diff --git a/pkg/localnet/localnet_race_test.go b/pkg/localnet/localnet_race_test.go index 339e021..de27d3e 100644 --- a/pkg/localnet/localnet_race_test.go +++ b/pkg/localnet/localnet_race_test.go @@ -23,6 +23,7 @@ func TestClassifyConcurrentWithStore(t *testing.T) { return BuildSnapshot( []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: []byte{10, 0, third, 5}}}, []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, []byte{10, 0, third, 0}, 24)}, + map[uint32]string{2: "eth0"}, ) } @@ -66,7 +67,12 @@ func TestClassifyConcurrentWithStore(t *testing.T) { defer rwg.Done() for i := 0; i < iters; i++ { snap := cur.Load() + // Exercise every lock-free reader against the swapping snapshot, + // including the Resolve fold used by the enrichment hot path. _ = snap.Classify(probes[i%len(probes)]) + _, oif, _ := snap.Lookup(probes[i%len(probes)]) + _ = snap.IfName(oif) + _ = snap.Resolve(probes[i%len(probes)], oif) } }() } @@ -83,8 +89,9 @@ var benchSink Locality // go test ./pkg/localnet/ -bench BenchmarkClassify -run x func BenchmarkClassify(b *testing.B) { snap := BuildSnapshot( - []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: []byte{10, 0, 0, 5}}}, - []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, []byte{10, 0, 0, 0}, 24)}, + []xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 2, Local: []byte{10, 0, 0, 5}}}, + []xtcpnl.RouteInfo{oifRoute(connectedRoute(unix.AF_INET, []byte{10, 0, 0, 0}, 24), 2)}, + map[uint32]string{2: "eth0"}, ) cases := []struct { diff --git a/pkg/localnet/localnet_realfixtures_test.go b/pkg/localnet/localnet_realfixtures_test.go index a13d772..0996b37 100644 --- a/pkg/localnet/localnet_realfixtures_test.go +++ b/pkg/localnet/localnet_realfixtures_test.go @@ -93,13 +93,31 @@ func buildRealSnapshot(t *testing.T) *Snapshot { routes = append(routes, ri) }) + links := make(map[uint32]string) + walkRealDump(t, "netlink_route_getlink_dump.pcap", func(mt uint16, body []byte) { + if mt != uint16(unix.RTM_NEWLINK) { + return + } + li, err := xtcpnl.ParseNewLink(body) + if err != nil { + t.Fatalf("getlink: ParseNewLink: %v", err) + } + links[uint32(li.Index)] = li.Name + }) + if len(addrs) != 24 { // 9 v4 + 15 v6 t.Fatalf("parsed %d addresses, want 24", len(addrs)) } if len(routes) != 74 { t.Fatalf("parsed %d routes, want 74", len(routes)) } - return BuildSnapshot(addrs, routes) + // ip_link_n sidecar: 1=lo, 2=enp1s0, 3=enp35s0f0np0 must be present. + for idx, name := range map[uint32]string{1: "lo", 2: "enp1s0", 3: "enp35s0f0np0"} { + if links[idx] != name { + t.Fatalf("links[%d] = %q, want %q", idx, links[idx], name) + } + } + return BuildSnapshot(addrs, routes, links) } // TestClassifyRealFixture classifies real destination addresses against a @@ -150,3 +168,47 @@ func TestClassifyRealFixture(t *testing.T) { }) } } + +// TestLookupEgressRealFixture asserts the egress interface derived from the real +// routing table: the Oif of the route each destination longest-prefix matches, +// resolved to a name via the RTM_GETLINK dump. Every row cites the +// ip_route_table_all_n line (dev ) the egress came from. Interface +// indices from ip_link_n: enp1s0=2, enp35s0f0np0=3, lo=1. +// +// go test ./pkg/localnet/ -run TestLookupEgressRealFixture +func TestLookupEgressRealFixture(t *testing.T) { + snap := buildRealSnapshot(t) + + tests := []struct { + description string + addr string + wantLoc Locality + wantIfindex uint32 + wantIfname string + }{ + // connected subnets -> egress is the subnet's dev + {"ip_route:2 10.10.4.5 in 10.10.4.0/29 dev enp35s0f0np0", "10.10.4.5", LocalitySubnet, 3, "enp35s0f0np0"}, + {"ip_route:6 172.16.50.100 in 172.16.50.0/24 dev enp1s0", "172.16.50.100", LocalitySubnet, 2, "enp1s0"}, + {"ip_route:29 fd10:10:4::abcd in fd10:10:4::/64 dev enp35s0f0np0", "fd10:10:4::abcd", LocalitySubnet, 3, "enp35s0f0np0"}, + {"ip_route:27 2603:…:6800::5 in 2603:8002:ea00:6800::/64 dev enp1s0", "2603:8002:ea00:6800::5", LocalitySubnet, 2, "enp1s0"}, + // remote -> egress from the matched default route + {"ip_route:1 8.8.8.8 via v4 default dev enp1s0", "8.8.8.8", LocalityRemote, 2, "enp1s0"}, + {"ip_route:39 2606:4700::1111 via v6 default dev enp1s0", "2606:4700::1111", LocalityRemote, 2, "enp1s0"}, + // self -> egress from the owning interface / RTN_LOCAL route dev + {"ip_route:19 self 172.16.50.219 dev enp1s0", "172.16.50.219", LocalitySelf, 2, "enp1s0"}, + {"ip_route:10 self 10.10.4.2 dev enp35s0f0np0", "10.10.4.2", LocalitySelf, 3, "enp35s0f0np0"}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + loc, oif, ok := snap.Lookup(netip.MustParseAddr(tc.addr)) + if !ok || loc != tc.wantLoc || oif != tc.wantIfindex { + t.Errorf("Lookup(%s) = (%v, %d, %v), want (%v, %d, true)", + tc.addr, loc, oif, ok, tc.wantLoc, tc.wantIfindex) + } + if name := snap.IfName(oif); name != tc.wantIfname { + t.Errorf("IfName(%d) = %q, want %q", oif, name, tc.wantIfname) + } + }) + } +} diff --git a/pkg/localnet/localnet_test.go b/pkg/localnet/localnet_test.go index a1f79df..570f6f9 100644 --- a/pkg/localnet/localnet_test.go +++ b/pkg/localnet/localnet_test.go @@ -32,22 +32,25 @@ func v6(t *testing.T, s string) []byte { } // connectedRoute builds a directly-connected (scope-link, gatewayless, unicast) -// route to dst/bits. +// main-table route to dst/bits. func connectedRoute(family uint8, dst []byte, bits uint8) xtcpnl.RouteInfo { return xtcpnl.RouteInfo{ Family: family, DstLen: bits, + Table: unix.RT_TABLE_MAIN, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_LINK, Dst: dst, } } -// gatewayRoute builds a route reached via a next-hop gateway (NOT connected). +// gatewayRoute builds a main-table route reached via a next-hop gateway (NOT +// connected). func gatewayRoute(family uint8, dst []byte, bits uint8, gw []byte) xtcpnl.RouteInfo { return xtcpnl.RouteInfo{ Family: family, DstLen: bits, + Table: unix.RT_TABLE_MAIN, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_UNIVERSE, Dst: dst, @@ -55,17 +58,52 @@ func gatewayRoute(family uint8, dst []byte, bits uint8, gw []byte) xtcpnl.RouteI } } -// localRoute builds an RTN_LOCAL route (a locally-attached host address). +// defaultRoute builds the kernel's form of a default route: no RTA_DST at all +// (Dst nil, DstLen 0) — BuildSnapshot must synthesise the family /0. gw may be +// nil for a gatewayless `default dev ` (point-to-point) route. +func defaultRoute(family uint8, gw []byte, oif uint32) xtcpnl.RouteInfo { + return xtcpnl.RouteInfo{ + Family: family, + DstLen: 0, + Table: unix.RT_TABLE_MAIN, + Type: unix.RTN_UNICAST, + Scope: unix.RT_SCOPE_UNIVERSE, + Gateway: gw, + Oif: oif, + } +} + +// localRoute builds an RTN_LOCAL host route (a locally-attached address) in the +// local table. func localRoute(family uint8, dst []byte) xtcpnl.RouteInfo { + return localRangeRoute(family, dst, uint8(len(dst)*8)) +} + +// localRangeRoute builds an RTN_LOCAL route covering dst/bits, as the kernel +// installs for `local 127.0.0.0/8 dev lo` or a `local` route added by hand. +func localRangeRoute(family uint8, dst []byte, bits uint8) xtcpnl.RouteInfo { return xtcpnl.RouteInfo{ Family: family, - DstLen: uint8(len(dst) * 8), + DstLen: bits, + Table: unix.RT_TABLE_LOCAL, Type: unix.RTN_LOCAL, Scope: unix.RT_SCOPE_HOST, Dst: dst, } } +// inTable returns r with its routing table id replaced (policy-routing tables). +func inTable(r xtcpnl.RouteInfo, table uint32) xtcpnl.RouteInfo { + r.Table = table + return r +} + +// withType returns r with its rtm_type replaced (RTN_BROADCAST, RTN_BLACKHOLE, …). +func withType(r xtcpnl.RouteInfo, typ uint8) xtcpnl.RouteInfo { + r.Type = typ + return r +} + // TestClassify feeds a BuildSnapshot-produced Snapshot a range of destination // addresses and asserts the classification. Every row carries a description and // the expected Locality, covering positive, negative, boundary and corner cases. @@ -86,7 +124,7 @@ func TestClassify(t *testing.T) { gatewayRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0, v4(t, "10.0.0.1")), // default via gw — must not create a subnet localRoute(unix.AF_INET, v4(t, "172.16.0.1")), } - snap := BuildSnapshot(addrs, routes) + snap := BuildSnapshot(addrs, routes, nil) tests := []struct { description string @@ -97,24 +135,24 @@ func TestClassify(t *testing.T) { {"self IPv4 address (IFA_LOCAL) -> self", "10.0.0.5", LocalitySelf}, {"self IPv6 address -> self", "2001:db8::5", LocalitySelf}, {"RTN_LOCAL host route dest -> self", "172.16.0.1", LocalitySelf}, - {"peer in connected IPv4 subnet -> connected_subnet", "10.0.0.42", LocalitySubnet}, - {"peer in connected IPv6 subnet -> connected_subnet", "2001:db8::1234", LocalitySubnet}, + {"peer in connected IPv4 subnet -> local_subnet", "10.0.0.42", LocalitySubnet}, + {"peer in connected IPv6 subnet -> local_subnet", "2001:db8::1234", LocalitySubnet}, // negative {"public IPv4 not in any set -> remote", "8.8.8.8", LocalityRemote}, {"public IPv6 not in any set -> remote", "2606:4700::1111", LocalityRemote}, {"address only reachable via gateway -> remote", "93.184.216.34", LocalityRemote}, {"IPv4 just outside connected /24 -> remote", "10.0.1.1", LocalityRemote}, // boundary - {"network address of connected subnet -> connected_subnet", "10.0.0.0", LocalitySubnet}, - {"broadcast-ish last host of /24 -> connected_subnet", "10.0.0.255", LocalitySubnet}, + {"network address of connected subnet -> local_subnet", "10.0.0.0", LocalitySubnet}, + {"broadcast-ish last host of /24 -> local_subnet", "10.0.0.255", LocalitySubnet}, {"self host /32 wins over containing /24 subnet", "10.0.0.5", LocalitySelf}, // corner {"IPv4 loopback short-circuits -> self", "127.0.0.1", LocalitySelf}, {"IPv6 loopback short-circuits -> self", "::1", LocalitySelf}, - {"IPv4 unspecified short-circuits -> self", "0.0.0.0", LocalitySelf}, - {"IPv6 unspecified short-circuits -> self", "::", LocalitySelf}, + {"IPv4 unspecified (LISTEN peer) is no destination -> unspecified", "0.0.0.0", LocalityUnspecified}, + {"IPv6 unspecified (LISTEN peer) is no destination -> unspecified", "::", LocalityUnspecified}, {"IPv4-mapped IPv6 of a self address -> self", "::ffff:10.0.0.5", LocalitySelf}, - {"IPv4-mapped IPv6 of a subnet peer -> connected_subnet", "::ffff:10.0.0.9", LocalitySubnet}, + {"IPv4-mapped IPv6 of a subnet peer -> local_subnet", "::ffff:10.0.0.9", LocalitySubnet}, } for _, tc := range tests { @@ -132,7 +170,7 @@ func TestClassify(t *testing.T) { // // go test ./pkg/localnet/ -run TestClassifyInvalidAndNil func TestClassifyInvalidAndNil(t *testing.T) { - empty := BuildSnapshot(nil, nil) + empty := BuildSnapshot(nil, nil, nil) tests := []struct { description string @@ -143,8 +181,10 @@ func TestClassifyInvalidAndNil(t *testing.T) { {"invalid zero address -> unspecified", empty, netip.Addr{}, LocalityUnspecified}, {"nil snapshot, valid remote address -> remote", nil, netip.MustParseAddr("8.8.8.8"), LocalityRemote}, {"nil snapshot, loopback still short-circuits -> self", nil, netip.MustParseAddr("127.0.0.1"), LocalitySelf}, + {"nil snapshot, unspecified address -> unspecified (not self, not remote)", nil, netip.MustParseAddr("0.0.0.0"), LocalityUnspecified}, {"empty snapshot, valid address -> remote", empty, netip.MustParseAddr("10.0.0.5"), LocalityRemote}, {"empty snapshot, invalid address -> unspecified", empty, netip.Addr{}, LocalityUnspecified}, + {"empty snapshot, v6 unspecified -> unspecified", empty, netip.MustParseAddr("::"), LocalityUnspecified}, } for _, tc := range tests { @@ -199,12 +239,24 @@ func TestBuildSnapshot(t *testing.T) { // IPv6 on-link subnet as remote. description: "universe-scope gatewayless unicast route (IPv6 connected subnet) -> subnet", routes: []xtcpnl.RouteInfo{{ - Family: unix.AF_INET6, DstLen: 64, Type: unix.RTN_UNICAST, + Family: unix.AF_INET6, DstLen: 64, Table: unix.RT_TABLE_MAIN, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_UNIVERSE, Dst: v6(t, "fd10:10:4::"), }}, probe: "fd10:10:4::7", want: LocalitySubnet, }, + { + description: "RTN_LOCAL range `local 127.0.0.0/8 dev lo` covers every loopback address as self", + routes: []xtcpnl.RouteInfo{localRangeRoute(unix.AF_INET, v4(t, "127.0.0.0"), 8)}, + probe: "127.0.0.5", + want: LocalitySelf, + }, + { + description: "RTN_LOCAL range (`ip route add local 10.200.0.0/24 dev lo`) makes the whole range self", + routes: []xtcpnl.RouteInfo{localRangeRoute(unix.AF_INET, v4(t, "10.200.0.0"), 24)}, + probe: "10.200.0.77", + want: LocalitySelf, + }, // negative { description: "route with a gateway is NOT a connected subnet", @@ -212,6 +264,81 @@ func TestBuildSnapshot(t *testing.T) { probe: "192.168.0.7", want: LocalityRemote, }, + { + description: "ECMP route (RTA_MULTIPATH, no RTA_GATEWAY of its own) is remote, not a subnet", + routes: []xtcpnl.RouteInfo{func() xtcpnl.RouteInfo { + r := connectedRoute(unix.AF_INET, v4(t, "10.20.0.0"), 16) + r.HasMultipath = true + return r + }()}, + probe: "10.20.1.1", + want: LocalityRemote, + }, + { + description: "route with a cross-family gateway (RTA_VIA, no RTA_GATEWAY) is remote", + routes: []xtcpnl.RouteInfo{func() xtcpnl.RouteInfo { + r := connectedRoute(unix.AF_INET, v4(t, "10.30.0.0"), 16) + r.HasVia = true + return r + }()}, + probe: "10.30.1.1", + want: LocalityRemote, + }, + { + description: "route pointing at a nexthop object (RTA_NH_ID, no RTA_GATEWAY) is remote", + routes: []xtcpnl.RouteInfo{func() xtcpnl.RouteInfo { + r := connectedRoute(unix.AF_INET, v4(t, "10.40.0.0"), 16) + r.NhID = 7 + return r + }()}, + probe: "10.40.1.1", + want: LocalityRemote, + }, + { + description: "connected route in a policy-routing table (100) is ignored -> remote", + routes: []xtcpnl.RouteInfo{inTable(connectedRoute(unix.AF_INET, v4(t, "10.50.0.0"), 24), 100)}, + probe: "10.50.0.9", + want: LocalityRemote, + }, + { + description: "RTN_LOCAL route in a policy-routing table (100) is ignored -> remote", + routes: []xtcpnl.RouteInfo{inTable(localRoute(unix.AF_INET, v4(t, "10.60.0.1")), 100)}, + probe: "10.60.0.1", + want: LocalityRemote, + }, + { + description: "route in RT_TABLE_DEFAULT (253) is ignored -> remote", + routes: []xtcpnl.RouteInfo{inTable(connectedRoute(unix.AF_INET, v4(t, "10.70.0.0"), 24), unix.RT_TABLE_DEFAULT)}, + probe: "10.70.0.9", + want: LocalityRemote, + }, + { + description: "RTN_BROADCAST route (local table, `broadcast 10.0.0.255 dev eth0`) is not self or subnet", + routes: []xtcpnl.RouteInfo{withType(localRoute(unix.AF_INET, v4(t, "10.80.0.255")), unix.RTN_BROADCAST)}, + probe: "10.80.0.255", + want: LocalityRemote, + }, + { + description: "RTN_BLACKHOLE route is ignored -> remote", + routes: []xtcpnl.RouteInfo{withType(connectedRoute(unix.AF_INET, v4(t, "10.90.0.0"), 24), unix.RTN_BLACKHOLE)}, + probe: "10.90.0.9", + want: LocalityRemote, + }, + { + description: "RTN_UNREACHABLE route is ignored -> remote", + routes: []xtcpnl.RouteInfo{withType(connectedRoute(unix.AF_INET, v4(t, "10.100.0.0"), 24), unix.RTN_UNREACHABLE)}, + probe: "10.100.0.9", + want: LocalityRemote, + }, + { + description: "gateway route more specific than a connected subnet wins -> remote", + routes: []xtcpnl.RouteInfo{ + connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 16), + gatewayRoute(unix.AF_INET, v4(t, "10.0.1.0"), 24, v4(t, "10.0.0.1")), + }, + probe: "10.0.1.5", + want: LocalityRemote, + }, // boundary { description: "/32 connected route classifies only that host", @@ -226,11 +353,57 @@ func TestBuildSnapshot(t *testing.T) { want: LocalityRemote, }, { - description: "scope-link /0 route is dropped (must not swallow everything)", + description: "gatewayless /0 with an explicit 0.0.0.0 Dst is remote, never a subnet (must not swallow everything)", routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0)}, probe: "8.8.8.8", want: LocalityRemote, }, + { + description: "kernel-form gatewayless default (`default dev wg0`: Dst nil, DstLen 0) is remote, never a subnet", + routes: []xtcpnl.RouteInfo{defaultRoute(unix.AF_INET, nil, 7)}, + probe: "8.8.8.8", + want: LocalityRemote, + }, + { + description: "kernel-form IPv6 default via gateway (Dst nil, DstLen 0) is remote", + routes: []xtcpnl.RouteInfo{defaultRoute(unix.AF_INET6, v6(t, "fe80::1"), 2)}, + probe: "2606:4700::1111", + want: LocalityRemote, + }, + { + description: "self address dumped BEFORE a same-prefix /32 unicast route stays self", + addrs: []xtcpnl.AddrInfo{{Family: unix.AF_INET, Local: v4(t, "10.0.0.5")}}, + routes: []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "10.0.0.5"), 32)}, + probe: "10.0.0.5", + want: LocalitySelf, + }, + { + description: "connected /32 route dumped BEFORE the RTN_LOCAL entry for the same address -> self", + routes: []xtcpnl.RouteInfo{ + connectedRoute(unix.AF_INET, v4(t, "10.0.0.5"), 32), + localRoute(unix.AF_INET, v4(t, "10.0.0.5")), + }, + probe: "10.0.0.5", + want: LocalitySelf, + }, + { + description: "RTN_LOCAL entry dumped BEFORE a same-prefix connected /32 route -> self", + routes: []xtcpnl.RouteInfo{ + localRoute(unix.AF_INET, v4(t, "10.0.0.5")), + connectedRoute(unix.AF_INET, v4(t, "10.0.0.5"), 32), + }, + probe: "10.0.0.5", + want: LocalitySelf, + }, + { + description: "gateway /32 host route for a self address (any dump order) -> self", + routes: []xtcpnl.RouteInfo{ + gatewayRoute(unix.AF_INET, v4(t, "10.0.0.5"), 32, v4(t, "10.0.0.1")), + localRoute(unix.AF_INET, v4(t, "10.0.0.5")), + }, + probe: "10.0.0.5", + want: LocalitySelf, + }, { description: "more-specific connected subnet still classifies as subnet", routes: []xtcpnl.RouteInfo{ @@ -242,8 +415,14 @@ func TestBuildSnapshot(t *testing.T) { }, // corner { - description: "zero-length Dst route skipped, address stays remote", - routes: []xtcpnl.RouteInfo{{Family: unix.AF_INET, DstLen: 24, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_LINK}}, + description: "zero-length Dst with a non-zero DstLen (malformed) is skipped, address stays remote", + routes: []xtcpnl.RouteInfo{{Family: unix.AF_INET, DstLen: 24, Table: unix.RT_TABLE_MAIN, Type: unix.RTN_UNICAST, Scope: unix.RT_SCOPE_LINK}}, + probe: "10.0.0.1", + want: LocalityRemote, + }, + { + description: "synthetic route with Table 0 (RT_TABLE_UNSPEC, never emitted by the kernel) is ignored", + routes: []xtcpnl.RouteInfo{inTable(connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 24), unix.RT_TABLE_UNSPEC)}, probe: "10.0.0.1", want: LocalityRemote, }, @@ -269,7 +448,7 @@ func TestBuildSnapshot(t *testing.T) { for _, tc := range tests { t.Run(tc.description, func(t *testing.T) { - snap := BuildSnapshot(tc.addrs, tc.routes) + snap := BuildSnapshot(tc.addrs, tc.routes, nil) got := snap.Classify(netip.MustParseAddr(tc.probe)) if got != tc.want { t.Errorf("Classify(%s) = %v, want %v", tc.probe, got, tc.want) @@ -278,6 +457,363 @@ func TestBuildSnapshot(t *testing.T) { } } +// oifRoute is a route helper that also sets the egress interface index. +func oifRoute(r xtcpnl.RouteInfo, oif uint32) xtcpnl.RouteInfo { + r.Oif = oif + return r +} + +// TestLookupEgressAndIfName asserts the richer Lookup result (Locality + egress +// interface index) and IfName resolution. The snapshot models a dual-stack +// namespace on eth0 (ifindex 2) with loopback lo (ifindex 1): +// - self v4 10.0.0.5 / v6 2001:db8::5 on eth0 +// - connected subnets 10.0.0.0/24 (eth0) and 2001:db8::/64 (eth0) +// - IPv4 default via 10.0.0.1 on eth0 (gateway route -> remote, egress kept) +// - RTN_LOCAL 127.0.0.1 on lo +// +// go test ./pkg/localnet/ -run TestLookupEgressAndIfName +func TestLookupEgressAndIfName(t *testing.T) { + addrs := []xtcpnl.AddrInfo{ + {Family: unix.AF_INET, Index: 2, Local: v4(t, "10.0.0.5"), Address: v4(t, "10.0.0.5")}, + {Family: unix.AF_INET6, Index: 2, Address: v6(t, "2001:db8::5")}, + } + routes := []xtcpnl.RouteInfo{ + oifRoute(connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 24), 2), + oifRoute(connectedRoute(unix.AF_INET6, v6(t, "2001:db8::"), 64), 2), + oifRoute(gatewayRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0, v4(t, "10.0.0.1")), 2), + oifRoute(localRoute(unix.AF_INET, v4(t, "127.0.0.1")), 1), + } + links := map[uint32]string{1: "lo", 2: "eth0"} + snap := BuildSnapshot(addrs, routes, links) + + tests := []struct { + description string + addr string + wantLoc Locality + wantOif uint32 + wantOk bool + wantIfName string // snap.IfName(gotOif) + }{ + // positive — locality + egress interface off the matched route + {"connected v4 peer -> subnet via eth0", "10.0.0.42", LocalitySubnet, 2, true, "eth0"}, + {"connected v6 peer -> subnet via eth0", "2001:db8::1234", LocalitySubnet, 2, true, "eth0"}, + {"self v4 -> self, egress from its address ifindex", "10.0.0.5", LocalitySelf, 2, true, "eth0"}, + {"remote v4 matches default route -> remote, egress eth0", "8.8.8.8", LocalityRemote, 2, true, "eth0"}, + // negative — no route matches, so no egress interface + {"remote v6 with no v6 default -> remote, no egress", "2606:4700::1111", LocalityRemote, 0, true, ""}, + // boundary — loopback short-circuits to self but still resolves lo egress + {"v4 loopback -> self via lo (RTN_LOCAL egress)", "127.0.0.1", LocalitySelf, 1, true, "lo"}, + {"v6 loopback -> self, no matching route -> no egress", "::1", LocalitySelf, 0, true, ""}, + // corner — invalid address + {"invalid address -> unspecified, not ok", "", LocalityUnspecified, 0, false, ""}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var addr netip.Addr + if tc.addr != "" { + addr = netip.MustParseAddr(tc.addr) + } + loc, oif, ok := snap.Lookup(addr) + if loc != tc.wantLoc || oif != tc.wantOif || ok != tc.wantOk { + t.Errorf("Lookup(%q) = (%v, %d, %v), want (%v, %d, %v)", + tc.addr, loc, oif, ok, tc.wantLoc, tc.wantOif, tc.wantOk) + } + if name := snap.IfName(oif); name != tc.wantIfName { + t.Errorf("IfName(%d) = %q, want %q", oif, name, tc.wantIfName) + } + }) + } +} + +// TestIfName covers interface-index resolution directly, including the zero, +// unknown and nil-snapshot corner cases. +// +// go test ./pkg/localnet/ -run TestIfName +func TestIfName(t *testing.T) { + snap := BuildSnapshot(nil, nil, map[uint32]string{1: "lo", 2: "eth0"}) + + tests := []struct { + description string + snap *Snapshot + index uint32 + want string + }{ + {"known index -> name", snap, 2, "eth0"}, + {"index 0 -> empty (kernel idiag_if unset)", snap, 0, ""}, + {"unknown index -> empty", snap, 999, ""}, + {"nil snapshot -> empty", nil, 2, ""}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if got := tc.snap.IfName(tc.index); got != tc.want { + t.Errorf("IfName(%d) = %q, want %q", tc.index, got, tc.want) + } + }) + } +} + +// TestDefaultPrefix covers the defaultPrefix helper directly: the kernel emits a +// default route with no RTA_DST, so BuildSnapshot must synthesise the family-wide +// /0 from the rtmsg family. Positive for both families, negative for anything else. +// +// go test ./pkg/localnet/ -run TestDefaultPrefix +func TestDefaultPrefix(t *testing.T) { + tests := []struct { + description string + family uint8 + wantOk bool + wantPfx string // only checked when wantOk + }{ + // positive + {"AF_INET -> 0.0.0.0/0", unix.AF_INET, true, "0.0.0.0/0"}, + {"AF_INET6 -> ::/0", unix.AF_INET6, true, "::/0"}, + // negative / corner — an unexpected family yields no prefix so the route + // is dropped rather than mapped to a bogus /0. + {"AF_UNSPEC -> not ok", unix.AF_UNSPEC, false, ""}, + {"AF_PACKET (bogus family) -> not ok", unix.AF_PACKET, false, ""}, + {"arbitrary high family byte -> not ok", 200, false, ""}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + pfx, ok := defaultPrefix(tc.family) + if ok != tc.wantOk { + t.Fatalf("defaultPrefix(%d) ok = %v, want %v", tc.family, ok, tc.wantOk) + } + if ok && pfx != netip.MustParsePrefix(tc.wantPfx) { + t.Errorf("defaultPrefix(%d) = %v, want %v", tc.family, pfx, tc.wantPfx) + } + }) + } +} + +// TestLookupEgressDefaultsAndPrecedence covers the egress-interface branches not +// exercised by TestLookupEgressAndIfName: both default routes in the kernel's +// RTA_DST-less form (the defaultPrefix AF_INET / AF_INET6 paths), longest-prefix +// egress precedence (a more-specific gateway route's Oif beating the default's), +// a connected subnet whose route has no Oif, a self address whose owning +// AddrInfo has Index 0, and an egress ifindex that is absent from the +// RTM_GETLINK map (IfName -> ""). The namespace: +// - self v4 10.0.0.5 with AddrInfo.Index 0 (no owning link recorded) +// - connected subnet 172.16.0.0/24 with Oif 0 (route carried no RTA_OIF) +// - IPv4 default via 10.0.0.1 on eth0 (ifindex 2), no RTA_DST +// - IPv6 default via fe80::1 on eth0 (ifindex 2), no RTA_DST +// - more-specific 203.0.113.0/24 via 10.0.0.1 on eth1 (ifindex 3) +// - more-specific 198.51.100.0/24 via 10.0.0.1 on ifindex 99 (NOT in links) +// +// go test ./pkg/localnet/ -run TestLookupEgressDefaultsAndPrecedence +func TestLookupEgressDefaultsAndPrecedence(t *testing.T) { + addrs := []xtcpnl.AddrInfo{ + {Family: unix.AF_INET, Index: 0, Local: v4(t, "10.0.0.5")}, + } + routes := []xtcpnl.RouteInfo{ + oifRoute(connectedRoute(unix.AF_INET, v4(t, "172.16.0.0"), 24), 0), + defaultRoute(unix.AF_INET, v4(t, "10.0.0.1"), 2), + defaultRoute(unix.AF_INET6, v6(t, "fe80::1"), 2), + oifRoute(gatewayRoute(unix.AF_INET, v4(t, "203.0.113.0"), 24, v4(t, "10.0.0.1")), 3), + oifRoute(gatewayRoute(unix.AF_INET, v4(t, "198.51.100.0"), 24, v4(t, "10.0.0.1")), 99), + } + links := map[uint32]string{2: "eth0", 3: "eth1"} // 99 deliberately absent + snap := BuildSnapshot(addrs, routes, links) + + tests := []struct { + description string + addr string + wantLoc Locality + wantOif uint32 + wantIfName string + }{ + // positive — RTA_DST-less default routes (defaultPrefix AF_INET6 / AF_INET) + {"remote v6 matches the synthesised ::/0 default -> remote via eth0", "2606:4700::1111", LocalityRemote, 2, "eth0"}, + {"remote v4 not in any specific route -> synthesised 0.0.0.0/0 default egress eth0", "8.8.8.8", LocalityRemote, 2, "eth0"}, + // positive — longest-prefix egress precedence: the /24 beats the /0 + {"remote v4 in a more-specific route -> its egress eth1", "203.0.113.9", LocalityRemote, 3, "eth1"}, + // boundary — connected subnet route with no Oif + {"connected subnet with Oif 0 -> subnet, no egress index", "172.16.0.42", LocalitySubnet, 0, ""}, + // boundary — self address whose AddrInfo.Index is 0 + {"self v4 with AddrInfo.Index 0 -> self, no egress index", "10.0.0.5", LocalitySelf, 0, ""}, + // corner — matched route's egress ifindex is not in the RTM_GETLINK map + {"remote v4 via ifindex absent from links -> index kept, name empty", "198.51.100.7", LocalityRemote, 99, ""}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + loc, oif, ok := snap.Lookup(netip.MustParseAddr(tc.addr)) + if !ok { + t.Fatalf("Lookup(%s) ok = false, want true", tc.addr) + } + if loc != tc.wantLoc || oif != tc.wantOif { + t.Errorf("Lookup(%s) = (%v, %d), want (%v, %d)", tc.addr, loc, oif, tc.wantLoc, tc.wantOif) + } + if name := snap.IfName(oif); name != tc.wantIfName { + t.Errorf("IfName(%d) = %q, want %q", oif, name, tc.wantIfName) + } + }) + } +} + +// TestResolve exercises the pure hot-path fold used by pkg/xtcp's applyEnrichment +// (which can't be unit-tested in place — its test binary won't link against the +// pinned giouring). Resolve must, in one call, classify the destination, resolve +// the matched route's egress Oif to a name, resolve the socket's own bound +// interface index (the kernel idiag_if) to a name, and report whether the +// destination is remote (the ASN-lookup gate). The namespace: +// - self v4 10.0.0.5 on eth0 (ifindex 2) +// - connected subnet 10.0.0.0/24 on eth0 +// - IPv4 default via 10.0.0.1 on eth0 +// - more-specific 203.0.113.0/24 via 10.0.0.1 on eth1 (ifindex 3) +// - links {1: lo, 2: eth0, 3: eth1} +// +// go test ./pkg/localnet/ -run TestResolve +func TestResolve(t *testing.T) { + addrs := []xtcpnl.AddrInfo{ + {Family: unix.AF_INET, Index: 2, Local: v4(t, "10.0.0.5")}, + } + routes := []xtcpnl.RouteInfo{ + oifRoute(connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 24), 2), + oifRoute(gatewayRoute(unix.AF_INET, v4(t, "0.0.0.0"), 0, v4(t, "10.0.0.1")), 2), + oifRoute(gatewayRoute(unix.AF_INET, v4(t, "203.0.113.0"), 24, v4(t, "10.0.0.1")), 3), + } + links := map[uint32]string{1: "lo", 2: "eth0", 3: "eth1"} + snap := BuildSnapshot(addrs, routes, links) + + tests := []struct { + description string + addr string + boundIfindex uint32 + want Resolution + }{ + // positive — self: not remote, egress from address, bound resolved + { + "self dest, socket bound to eth0", + "10.0.0.5", 2, + Resolution{Locality: LocalitySelf, EgressIfindex: 2, EgressIfname: "eth0", BoundIfname: "eth0", Remote: false}, + }, + // positive — connected subnet: not remote, bound idiag_if unset (0 -> "") + { + "connected-subnet dest, socket bound to nothing (idiag_if 0)", + "10.0.0.42", 0, + Resolution{Locality: LocalitySubnet, EgressIfindex: 2, EgressIfname: "eth0", BoundIfname: "", Remote: false}, + }, + // positive — remote via default: remote gate true, both names resolved + { + "remote dest via default route, bound to eth0", + "8.8.8.8", 2, + Resolution{Locality: LocalityRemote, EgressIfindex: 2, EgressIfname: "eth0", BoundIfname: "eth0", Remote: true}, + }, + // positive — remote via a more-specific route: distinct egress interface + { + "remote dest via more-specific route, bound to eth1", + "203.0.113.9", 3, + Resolution{Locality: LocalityRemote, EgressIfindex: 3, EgressIfname: "eth1", BoundIfname: "eth1", Remote: true}, + }, + // negative — no matching route: remote, no egress, bound still resolved + { + "remote v6 with no v6 route -> remote, no egress, bound lo", + "2606:4700::1111", 1, + Resolution{Locality: LocalityRemote, EgressIfindex: 0, EgressIfname: "", BoundIfname: "lo", Remote: true}, + }, + // boundary — loopback short-circuits locality to self (not remote); the LPM + // matches only the /0 default (a gateway route loopback traffic never + // uses), so no egress is reported rather than the default's eth0. + { + "loopback dest -> self, no egress (default route is not loopback's path), bound eth0", + "127.0.0.1", 2, + Resolution{Locality: LocalitySelf, EgressIfindex: 0, EgressIfname: "", BoundIfname: "eth0", Remote: false}, + }, + // boundary — unspecified destination (a LISTEN socket's peer): not a + // destination at all, so unclassified, no egress, and not remote (no ASN + // lookup); the bound interface still resolves. + { + "unspecified dest (LISTEN peer 0.0.0.0) -> unspecified, not remote, bound eth0", + "0.0.0.0", 2, + Resolution{Locality: LocalityUnspecified, EgressIfindex: 0, EgressIfname: "", BoundIfname: "eth0", Remote: false}, + }, + // corner — bound idiag_if index absent from the RTM_GETLINK map -> "" + { + "remote dest, socket bound to an ifindex not in links", + "8.8.8.8", 99, + Resolution{Locality: LocalityRemote, EgressIfindex: 2, EgressIfname: "eth0", BoundIfname: "", Remote: true}, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got := snap.Resolve(netip.MustParseAddr(tc.addr), tc.boundIfindex) + if got != tc.want { + t.Errorf("Resolve(%s, %d) = %+v, want %+v", tc.addr, tc.boundIfindex, got, tc.want) + } + }) + } +} + +// TestLookupGatewaylessDefaultAndLoopbackEgress covers the egress rules for +// routes that name no single next hop: a gatewayless `default dev wg0` +// (point-to-point) route supplies its egress to every unmatched destination but +// is never a local subnet; an ECMP (RTA_MULTIPATH) route and a nexthop-object +// (RTA_NH_ID) route are remote with NO egress, because they have several / +// opaque egress interfaces and a single wrong Oif is worse than none; loopback +// takes its egress only from a covering self entry (the kernel's +// `local 127.0.0.0/8 dev lo`), never from the default route. The namespace: +// - `default dev wg0` (ifindex 7), gatewayless, no RTA_DST +// - 10.20.0.0/16 ECMP (RTA_MULTIPATH) with RTA_OIF absent +// - 10.40.0.0/16 via nexthop object 5 (RTA_NH_ID) +// - `local 127.0.0.0/8 dev lo` (ifindex 1) — IPv4 only; no ::1 local route +// - links {1: lo, 7: wg0} +// +// go test ./pkg/localnet/ -run TestLookupGatewaylessDefaultAndLoopbackEgress +func TestLookupGatewaylessDefaultAndLoopbackEgress(t *testing.T) { + ecmp := connectedRoute(unix.AF_INET, v4(t, "10.20.0.0"), 16) + ecmp.HasMultipath = true + nh := connectedRoute(unix.AF_INET, v4(t, "10.40.0.0"), 16) + nh.NhID = 5 + nh.Oif = 9 // an RTA_OIF alongside RTA_NH_ID is not trusted either + routes := []xtcpnl.RouteInfo{ + defaultRoute(unix.AF_INET, nil, 7), + ecmp, + nh, + oifRoute(localRangeRoute(unix.AF_INET, v4(t, "127.0.0.0"), 8), 1), + } + links := map[uint32]string{1: "lo", 7: "wg0"} + snap := BuildSnapshot(nil, routes, links) + + tests := []struct { + description string + addr string + wantLoc Locality + wantOif uint32 + wantIfName string + }{ + // positive — gatewayless default supplies the egress + {"remote v4 via `default dev wg0` -> remote, egress wg0", "8.8.8.8", LocalityRemote, 7, "wg0"}, + {"address inside the /0 only is remote, not local subnet", "192.0.2.1", LocalityRemote, 7, "wg0"}, + // negative — multi-nexthop routes report no egress + {"ECMP (RTA_MULTIPATH) dest -> remote, no egress", "10.20.3.4", LocalityRemote, 0, ""}, + {"nexthop-object (RTA_NH_ID) dest -> remote, no egress even with a stray RTA_OIF", "10.40.3.4", LocalityRemote, 0, ""}, + // boundary — loopback egress comes from the local-table range, not the default + {"v4 loopback -> self via lo from `local 127.0.0.0/8`", "127.0.0.1", LocalitySelf, 1, "lo"}, + {"any 127/8 address -> self via lo", "127.255.255.254", LocalitySelf, 1, "lo"}, + {"v6 loopback with no ::1 local route -> self, no egress (never the default's)", "::1", LocalitySelf, 0, ""}, + // corner — unspecified is not a destination + {"unspecified v4 -> unspecified, no egress (not the default's wg0)", "0.0.0.0", LocalityUnspecified, 0, ""}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + loc, oif, ok := snap.Lookup(netip.MustParseAddr(tc.addr)) + if !ok { + t.Fatalf("Lookup(%s) ok = false, want true", tc.addr) + } + if loc != tc.wantLoc || oif != tc.wantOif { + t.Errorf("Lookup(%s) = (%v, %d), want (%v, %d)", tc.addr, loc, oif, tc.wantLoc, tc.wantOif) + } + if name := snap.IfName(oif); name != tc.wantIfName { + t.Errorf("IfName(%d) = %q, want %q", oif, name, tc.wantIfName) + } + }) + } +} + // TestLocalityString checks the human-readable rendering used in logs/columns, // including the out-of-range corner value. // @@ -289,7 +825,7 @@ func TestLocalityString(t *testing.T) { want string }{ {"self", LocalitySelf, "self"}, - {"subnet", LocalitySubnet, "connected_subnet"}, + {"subnet", LocalitySubnet, "local_subnet"}, {"remote", LocalityRemote, "remote"}, {"unspecified zero value", LocalityUnspecified, "unspecified"}, {"out-of-range value falls back to unspecified", Locality(200), "unspecified"}, @@ -302,3 +838,63 @@ func TestLocalityString(t *testing.T) { }) } } + +// TestHasNonLoopbackSelf covers the loopback-only detector the daemon uses to +// re-dump a namespace whose veth has not been plumbed yet. +// +// go test ./pkg/localnet/ -run TestHasNonLoopbackSelf +func TestHasNonLoopbackSelf(t *testing.T) { + lo4 := xtcpnl.AddrInfo{Family: unix.AF_INET, Index: 1, Local: v4(t, "127.0.0.1")} + lo6 := xtcpnl.AddrInfo{Family: unix.AF_INET6, Index: 1, Address: v6(t, "::1")} + + tests := []struct { + description string + snap *Snapshot + want bool + }{ + // positive + {"non-loopback IFA_LOCAL -> true", + BuildSnapshot([]xtcpnl.AddrInfo{lo4, lo6, {Family: unix.AF_INET, Index: 2, Local: v4(t, "10.1.2.3")}}, nil, nil), true}, + {"non-loopback via IFA_ADDRESS fallback -> true", + BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET6, Index: 2, Address: v6(t, "fd00::1")}}, nil, nil), true}, + {"IPv6 link-local only (fe80::) still counts as non-loopback -> true", + BuildSnapshot([]xtcpnl.AddrInfo{lo4, {Family: unix.AF_INET6, Index: 2, Address: v6(t, "fe80::1")}}, nil, nil), true}, + {"RTN_LOCAL host route with no address entry -> true", + BuildSnapshot(nil, []xtcpnl.RouteInfo{localRoute(unix.AF_INET, v4(t, "10.1.2.3"))}, nil), true}, + + // negative + {"nil snapshot -> false", nil, false}, + {"zero snapshot -> false", &Snapshot{}, false}, + {"no addresses, no routes -> false", BuildSnapshot(nil, nil, nil), false}, + {"lo addresses + kernel lo routes only -> false", + BuildSnapshot([]xtcpnl.AddrInfo{lo4, lo6}, + []xtcpnl.RouteInfo{localRangeRoute(unix.AF_INET, v4(t, "127.0.0.0"), 8), localRoute(unix.AF_INET6, v6(t, "::1"))}, nil), false}, + {"connected subnet route but no self address -> false (subnet is not self)", + BuildSnapshot([]xtcpnl.AddrInfo{lo4}, []xtcpnl.RouteInfo{connectedRoute(unix.AF_INET, v4(t, "10.0.0.0"), 24)}, nil), false}, + {"RTN_LOCAL in an ignored policy table does not count -> false", + BuildSnapshot([]xtcpnl.AddrInfo{lo4}, []xtcpnl.RouteInfo{inTable(localRoute(unix.AF_INET, v4(t, "10.1.2.3")), 100)}, nil), false}, + + // boundary + {"127.255.255.254 (top of loopback range) -> false", + BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 1, Local: v4(t, "127.255.255.254")}}, nil, nil), false}, + {"128.0.0.1 (just past loopback range) -> true", + BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 2, Local: v4(t, "128.0.0.1")}}, nil, nil), true}, + {"::2 (not the v6 loopback) -> true", + BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET6, Index: 2, Address: v6(t, "::2")}}, nil, nil), true}, + + // corner + {"local 127.0.0.0/7 route (wider than the loopback range) -> true", + BuildSnapshot(nil, []xtcpnl.RouteInfo{localRangeRoute(unix.AF_INET, v4(t, "126.0.0.0"), 7)}, nil), true}, + {"local ::1/127 route (wider than ::1/128) -> true", + BuildSnapshot(nil, []xtcpnl.RouteInfo{localRangeRoute(unix.AF_INET6, v6(t, "::"), 127)}, nil), true}, + {"unparseable address bytes are ignored -> false", + BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 2, Local: []byte{1, 2, 3}}}, nil, nil), false}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if got := tc.snap.HasNonLoopbackSelf(); got != tc.want { + t.Errorf("HasNonLoopbackSelf() = %v, want %v", got, tc.want) + } + }) + } +} diff --git a/pkg/recordfmt/bench_test.go b/pkg/recordfmt/bench_test.go index 2aa80e1..b404a69 100644 --- a/pkg/recordfmt/bench_test.go +++ b/pkg/recordfmt/bench_test.go @@ -24,14 +24,14 @@ func benchRecord() *xtcp_flat_record.XtcpFlatRecord { InetDiagMsgSocketDestination: []byte(net.ParseIP("10.0.12.99").To4()), InetDiagMsgSocketDestinationPort: 51514, TcpInfoState: 1, - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, TcpInfoRtt: 18234, - TcpInfoRttVar: 4096, + TcpInfoRttvar: 4096, TcpInfoMinRtt: 12011, TcpInfoSndCwnd: 64, TcpInfoSndMss: 1448, TcpInfoRcvMss: 536, - TcpInfoAdvMss: 1460, + TcpInfoAdvmss: 1460, TcpInfoBytesAcked: 104857600, TcpInfoBytesReceived: 52428800, TcpInfoBytesSent: 104900000, diff --git a/pkg/recordfmt/columns.go b/pkg/recordfmt/columns.go index 4e5c500..cc5487e 100644 --- a/pkg/recordfmt/columns.go +++ b/pkg/recordfmt/columns.go @@ -105,10 +105,10 @@ func formatField(r *xtcp_flat_record.XtcpFlatRecord, m protoreflect.Message, c C return TCPStateName(r.GetInetDiagMsgState()) case "tcpInfoState": return TCPStateName(r.GetTcpInfoState()) - case "congestionAlgorithmEnum": - return CongestionAlgorithmName(r.GetCongestionAlgorithmEnum()) - case "inetDiagMsgSocketDestLocality": - return LocalityName(r.GetInetDiagMsgSocketDestLocality()) + case "inetDiagCongEnum": + return CongestionAlgorithmName(r.GetInetDiagCongEnum()) + case "enrichSocketDestLocality": + return LocalityName(r.GetEnrichSocketDestLocality()) case "timestampNs": return TimestampRFC3339(r.GetTimestampNs()) } diff --git a/pkg/recordfmt/marshal.go b/pkg/recordfmt/marshal.go index 7eba62d..c8af765 100644 --- a/pkg/recordfmt/marshal.go +++ b/pkg/recordfmt/marshal.go @@ -82,7 +82,7 @@ func MarshalHumanizedJSON(r *xtcp_flat_record.XtcpFlatRecord) ([]byte, error) { {"inetDiagMsgSocketDestination", IPString(r.GetInetDiagMsgFamily(), r.GetInetDiagMsgSocketDestination())}, {"inetDiagMsgState", TCPStateName(r.GetInetDiagMsgState())}, {"tcpInfoState", TCPStateName(r.GetTcpInfoState())}, - {"congestionAlgorithmEnum", CongestionAlgorithmName(r.GetCongestionAlgorithmEnum())}, + {"inetDiagCongEnum", CongestionAlgorithmName(r.GetInetDiagCongEnum())}, {"timestampNs", TimestampRFC3339(r.GetTimestampNs())}, } { if err := set(kv[0], kv[1]); err != nil { diff --git a/pkg/recordfmt/protobuflist_vt_test.go b/pkg/recordfmt/protobuflist_vt_test.go index c0698f3..4fd976c 100644 --- a/pkg/recordfmt/protobuflist_vt_test.go +++ b/pkg/recordfmt/protobuflist_vt_test.go @@ -22,7 +22,7 @@ func vtEnvelope(rows int) *xtcp_flat_record.Envelope { InetDiagMsgState: 1, InetDiagMsgSocketSource: []byte(net.ParseIP("10.0.0.5").To4()), InetDiagMsgSocketSourcePort: 443, - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, TcpInfoRtt: uint32(18000 + i), TcpInfoMinRtt: 12011, TcpInfoSndCwnd: 64, diff --git a/pkg/recordfmt/recordfmt_test.go b/pkg/recordfmt/recordfmt_test.go index 5d7e7b7..bd17198 100644 --- a/pkg/recordfmt/recordfmt_test.go +++ b/pkg/recordfmt/recordfmt_test.go @@ -19,7 +19,7 @@ func sampleRecord() *xtcp_flat_record.XtcpFlatRecord { InetDiagMsgSocketSourcePort: 443, InetDiagMsgState: 10, // LISTEN TcpInfoState: 10, - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC, } } @@ -51,14 +51,32 @@ func TestIPString(t *testing.T) { } func TestTCPStateAndCongestionNames(t *testing.T) { - if TCPStateName(10) != "LISTEN" || TCPStateName(1) != "ESTABLISHED" || TCPStateName(99) != "99" { - t.Error("TCPStateName mismatch") - } - if CongestionAlgorithmName(xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC) != "CUBIC" { - t.Error("congestion name mismatch") - } - if CongestionAlgorithmName(xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_UNSPECIFIED) != "" { - t.Error("unspecified congestion should be empty") + tests := []struct { + description string + got string + want string + }{ + // TCPStateName + {"tcp state 10 -> LISTEN", TCPStateName(10), "LISTEN"}, + {"tcp state 1 -> ESTABLISHED", TCPStateName(1), "ESTABLISHED"}, + {"tcp state 0 (unset) -> numeric fallback", TCPStateName(0), "0"}, + {"tcp state 99 (unknown) -> numeric fallback", TCPStateName(99), "99"}, + // CongestionAlgorithmName + {"congestion CUBIC -> CUBIC", CongestionAlgorithmName(xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC), "CUBIC"}, + {"congestion UNSPECIFIED -> empty", CongestionAlgorithmName(xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_UNSPECIFIED), ""}, + // LocalityName: enum prefix stripped, unspecified empty, unknown value numeric + {"locality SELF -> SELF", LocalityName(xtcp_flat_record.XtcpFlatRecord_LOCALITY_SELF), "SELF"}, + {"locality LOCAL_SUBNET -> LOCAL_SUBNET", LocalityName(xtcp_flat_record.XtcpFlatRecord_LOCALITY_LOCAL_SUBNET), "LOCAL_SUBNET"}, + {"locality REMOTE -> REMOTE", LocalityName(xtcp_flat_record.XtcpFlatRecord_LOCALITY_REMOTE), "REMOTE"}, + {"locality UNSPECIFIED -> empty (column left blank)", LocalityName(xtcp_flat_record.XtcpFlatRecord_LOCALITY_UNSPECIFIED), ""}, + {"locality out-of-range 42 -> numeric fallback", LocalityName(xtcp_flat_record.XtcpFlatRecord_Locality(42)), "42"}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if tc.got != tc.want { + t.Errorf("got %q, want %q", tc.got, tc.want) + } + }) } } @@ -107,8 +125,8 @@ func TestMarshalHumanizedJSON(t *testing.T) { if m["inetDiagMsgState"] != "LISTEN" { t.Errorf("state not humanized: %v", m["inetDiagMsgState"]) } - if m["congestionAlgorithmEnum"] != "CUBIC" { - t.Errorf("congestion not humanized: %v", m["congestionAlgorithmEnum"]) + if m["inetDiagCongEnum"] != "CUBIC" { + t.Errorf("congestion not humanized: %v", m["inetDiagCongEnum"]) } // A non-special numeric field stays a JSON number. if _, ok := m["inetDiagMsgSocketSourcePort"].(float64); !ok { diff --git a/pkg/xtcp/deserialize.go b/pkg/xtcp/deserialize.go index 5c84968..ac7df95 100644 --- a/pkg/xtcp/deserialize.go +++ b/pkg/xtcp/deserialize.go @@ -225,8 +225,8 @@ func (x *XTCP) processInetDiagRecord( // already identify the container — e.g. host-net container sockets that // carry a container cgroup but no distinct netns inode. O(1) cached lookup; // empty when the resolver is disabled or the cgroup isn't a container. - if xtcpRecord.ContainerId == "" && x.cgroupResolver != nil && xtcpRecord.CGroup != 0 { - xtcpRecord.ContainerId, xtcpRecord.ContainerRuntime = x.cgroupResolver.Resolve(xtcpRecord.CGroup) + if xtcpRecord.ContainerId == "" && x.cgroupResolver != nil && xtcpRecord.InetDiagCgroupId != 0 { + xtcpRecord.ContainerId, xtcpRecord.ContainerRuntime = x.cgroupResolver.Resolve(xtcpRecord.InetDiagCgroupId) } if x.debugLevel > 1000 { @@ -322,7 +322,7 @@ func (x *XTCP) skipUnknownNlmsg(d DeserializeArgs, nlh *xtcpnl.NlMsgHdr, offset, // We need to do this because these won't get over written each time func (x *XTCP) ZeroXTCPCongRecord(xtcpRecord *xtcp_flat_record.XtcpFlatRecord) { // func (x *XTCP) ZeroXTCPCongRecord(xtcpRecord *xtcp_flat_record.Envelope_XtcpFlatRecord) { - if zeroer, ok := x.xtcpRecordZeroizer[xtcpRecord.CongestionAlgorithmEnum]; ok { + if zeroer, ok := x.xtcpRecordZeroizer[xtcpRecord.InetDiagCongEnum]; ok { zeroer(xtcpRecord) } } diff --git a/pkg/xtcp/deserialize_test.go b/pkg/xtcp/deserialize_test.go index 278f088..7a5a6a5 100644 --- a/pkg/xtcp/deserialize_test.go +++ b/pkg/xtcp/deserialize_test.go @@ -393,11 +393,12 @@ func TestDeserialize_stampsRecordProvenance(t *testing.T) { } // TestSchemaVersionConstant guards against an accidental bump: the current -// (enrichment-era) format is epoch 1. Bumping this constant is a deliberate act -// that must be paired with a new _vN table + MV in the ClickHouse initdb. +// (kernel-spelled payload names, regrouped enrichment block) format is epoch 2. +// Bumping this constant is a deliberate act that must be paired with a new _vN +// table + MV in the ClickHouse initdb and a sql/migrations/vN.sql. func TestSchemaVersionConstant(t *testing.T) { - if XtcpFlatRecordSchemaVersion != 1 { - t.Errorf("XtcpFlatRecordSchemaVersion = %d, want 1 (bumping requires a matching _vN table + MV)", XtcpFlatRecordSchemaVersion) + if XtcpFlatRecordSchemaVersion != 2 { + t.Errorf("XtcpFlatRecordSchemaVersion = %d, want 2 (bumping requires a matching _vN table + MV + sql/migrations/vN.sql)", XtcpFlatRecordSchemaVersion) } } diff --git a/pkg/xtcp/destinations_s3parquet.go b/pkg/xtcp/destinations_s3parquet.go index 0138be1..f01358c 100644 --- a/pkg/xtcp/destinations_s3parquet.go +++ b/pkg/xtcp/destinations_s3parquet.go @@ -729,7 +729,7 @@ func approxRowBytes(r *xtcp_flat_record.XtcpFlatRecord) int { const numericBaseline = 800 n := numericBaseline n += len(r.Hostname) + len(r.Netns) + len(r.Label) + len(r.Tag) + - len(r.CongestionAlgorithmString) + len(r.InetDiagCong) n += len(r.InetDiagMsgSocketSource) + len(r.InetDiagMsgSocketDestination) return n } @@ -746,16 +746,22 @@ func utcDateFromNs(ns int64) string { // destinations_s3parquet_schema_test.go. func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { return ParquetRow{ + SchemaVersion: r.SchemaVersion, + DaemonVersion: r.DaemonVersion, + TimestampNs: r.TimestampNs, Hostname: r.Hostname, Location: r.Location, - Netns: r.Netns, - NetnsInode: r.NetnsInode, + Netns: r.Netns, + NetnsInode: r.NetnsInode, + Nsid: r.Nsid, + ContainerId: r.ContainerId, ContainerRuntime: r.ContainerRuntime, - Nsid: r.Nsid, + ContainerName: r.ContainerName, + ContainerImage: r.ContainerImage, Label: r.Label, Tag: r.Tag, @@ -764,25 +770,57 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { SocketFd: r.SocketFd, NetlinkerId: r.NetlinkerId, - InetDiagMsgFamily: r.InetDiagMsgFamily, - InetDiagMsgState: r.InetDiagMsgState, - InetDiagMsgTimer: r.InetDiagMsgTimer, - InetDiagMsgRetrans: r.InetDiagMsgRetrans, - InetDiagMsgSocketSourcePort: r.InetDiagMsgSocketSourcePort, - InetDiagMsgSocketDestinationPort: r.InetDiagMsgSocketDestinationPort, - InetDiagMsgSocketSource: r.InetDiagMsgSocketSource, - InetDiagMsgSocketDestination: r.InetDiagMsgSocketDestination, - InetDiagMsgSocketInterface: r.InetDiagMsgSocketInterface, - InetDiagMsgSocketCookie: r.InetDiagMsgSocketCookie, - InetDiagMsgSocketDestAsn: r.InetDiagMsgSocketDestAsn, - InetDiagMsgSocketNextHopAsn: r.InetDiagMsgSocketNextHopAsn, - InetDiagMsgSocketDestNetworkOwner: r.InetDiagMsgSocketDestNetworkOwner, - InetDiagMsgSocketDestLocality: int32(r.InetDiagMsgSocketDestLocality), - InetDiagMsgExpires: r.InetDiagMsgExpires, - InetDiagMsgRqueue: r.InetDiagMsgRqueue, - InetDiagMsgWqueue: r.InetDiagMsgWqueue, - InetDiagMsgUid: r.InetDiagMsgUid, - InetDiagMsgInode: r.InetDiagMsgInode, + Uplink1Ifname: r.Uplink1Ifname, + Uplink1NicDriver: r.Uplink1NicDriver, + Uplink1NicModel: r.Uplink1NicModel, + Uplink1NicPciVendor: r.Uplink1NicPciVendor, + Uplink1NicPciDevice: r.Uplink1NicPciDevice, + Uplink1NicBusInfo: r.Uplink1NicBusInfo, + Uplink1NicSpeedMbps: r.Uplink1NicSpeedMbps, + Uplink1NicFwVersion: r.Uplink1NicFwVersion, + Uplink1LldpChassisName: r.Uplink1LldpChassisName, + Uplink1LldpChassisId: r.Uplink1LldpChassisId, + Uplink1LldpMgmtIp: r.Uplink1LldpMgmtIp, + Uplink1LldpPortId: r.Uplink1LldpPortId, + Uplink1LldpPortDescr: r.Uplink1LldpPortDescr, + + Uplink2Ifname: r.Uplink2Ifname, + Uplink2NicDriver: r.Uplink2NicDriver, + Uplink2NicModel: r.Uplink2NicModel, + Uplink2NicPciVendor: r.Uplink2NicPciVendor, + Uplink2NicPciDevice: r.Uplink2NicPciDevice, + Uplink2NicBusInfo: r.Uplink2NicBusInfo, + Uplink2NicSpeedMbps: r.Uplink2NicSpeedMbps, + Uplink2NicFwVersion: r.Uplink2NicFwVersion, + Uplink2LldpChassisName: r.Uplink2LldpChassisName, + Uplink2LldpChassisId: r.Uplink2LldpChassisId, + Uplink2LldpMgmtIp: r.Uplink2LldpMgmtIp, + Uplink2LldpPortId: r.Uplink2LldpPortId, + Uplink2LldpPortDescr: r.Uplink2LldpPortDescr, + + EnrichSocketInterfaceName: r.EnrichSocketInterfaceName, + EnrichSocketDestLocality: int32(r.EnrichSocketDestLocality), + EnrichSocketDestEgressIfindex: r.EnrichSocketDestEgressIfindex, + EnrichSocketDestEgressIfname: r.EnrichSocketDestEgressIfname, + EnrichSocketDestAsn: r.EnrichSocketDestAsn, + EnrichSocketDestNextHopAsn: r.EnrichSocketDestNextHopAsn, + EnrichSocketDestNetworkOwner: r.EnrichSocketDestNetworkOwner, + + InetDiagMsgFamily: r.InetDiagMsgFamily, + InetDiagMsgState: r.InetDiagMsgState, + InetDiagMsgTimer: r.InetDiagMsgTimer, + InetDiagMsgRetrans: r.InetDiagMsgRetrans, + InetDiagMsgSocketSourcePort: r.InetDiagMsgSocketSourcePort, + InetDiagMsgSocketDestinationPort: r.InetDiagMsgSocketDestinationPort, + InetDiagMsgSocketSource: r.InetDiagMsgSocketSource, + InetDiagMsgSocketDestination: r.InetDiagMsgSocketDestination, + InetDiagMsgSocketInterface: r.InetDiagMsgSocketInterface, + InetDiagMsgSocketCookie: r.InetDiagMsgSocketCookie, + InetDiagMsgExpires: r.InetDiagMsgExpires, + InetDiagMsgRqueue: r.InetDiagMsgRqueue, + InetDiagMsgWqueue: r.InetDiagMsgWqueue, + InetDiagMsgUid: r.InetDiagMsgUid, + InetDiagMsgInode: r.InetDiagMsgInode, MemInfoRmem: r.MemInfoRmem, MemInfoWmem: r.MemInfoWmem, @@ -795,10 +833,10 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { TcpInfoProbes: r.TcpInfoProbes, TcpInfoBackoff: r.TcpInfoBackoff, TcpInfoOptions: r.TcpInfoOptions, - TcpInfoSendScale: r.TcpInfoSendScale, - TcpInfoRcvScale: r.TcpInfoRcvScale, + TcpInfoSndWscale: r.TcpInfoSndWscale, + TcpInfoRcvWscale: r.TcpInfoRcvWscale, TcpInfoDeliveryRateAppLimited: r.TcpInfoDeliveryRateAppLimited, - TcpInfoFastOpenClientFailed: r.TcpInfoFastOpenClientFailed, + TcpInfoFastopenClientFail: r.TcpInfoFastopenClientFail, TcpInfoRto: r.TcpInfoRto, TcpInfoAto: r.TcpInfoAto, TcpInfoSndMss: r.TcpInfoSndMss, @@ -815,10 +853,10 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { TcpInfoPmtu: r.TcpInfoPmtu, TcpInfoRcvSsthresh: r.TcpInfoRcvSsthresh, TcpInfoRtt: r.TcpInfoRtt, - TcpInfoRttVar: r.TcpInfoRttVar, + TcpInfoRttvar: r.TcpInfoRttvar, TcpInfoSndSsthresh: r.TcpInfoSndSsthresh, TcpInfoSndCwnd: r.TcpInfoSndCwnd, - TcpInfoAdvMss: r.TcpInfoAdvMss, + TcpInfoAdvmss: r.TcpInfoAdvmss, TcpInfoReordering: r.TcpInfoReordering, TcpInfoRcvRtt: r.TcpInfoRcvRtt, TcpInfoRcvSpace: r.TcpInfoRcvSpace, @@ -829,7 +867,7 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { TcpInfoBytesReceived: r.TcpInfoBytesReceived, TcpInfoSegsOut: r.TcpInfoSegsOut, TcpInfoSegsIn: r.TcpInfoSegsIn, - TcpInfoNotSentBytes: r.TcpInfoNotSentBytes, + TcpInfoNotsentBytes: r.TcpInfoNotsentBytes, TcpInfoMinRtt: r.TcpInfoMinRtt, TcpInfoDataSegsIn: r.TcpInfoDataSegsIn, TcpInfoDataSegsOut: r.TcpInfoDataSegsOut, @@ -851,28 +889,28 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { TcpInfoTotalRtoRecoveries: r.TcpInfoTotalRtoRecoveries, TcpInfoTotalRtoTime: r.TcpInfoTotalRtoTime, - CongestionAlgorithmString: r.CongestionAlgorithmString, - CongestionAlgorithmEnum: int32(r.CongestionAlgorithmEnum), + InetDiagCong: r.InetDiagCong, + InetDiagCongEnum: int32(r.InetDiagCongEnum), - TypeOfService: r.TypeOfService, - TrafficClass: r.TrafficClass, + InetDiagTos: r.InetDiagTos, + InetDiagTclass: r.InetDiagTclass, SkMemInfoRmemAlloc: r.SkMemInfoRmemAlloc, - SkMemInfoRcvBuf: r.SkMemInfoRcvBuf, + SkMemInfoRcvbuf: r.SkMemInfoRcvbuf, SkMemInfoWmemAlloc: r.SkMemInfoWmemAlloc, - SkMemInfoSndBuf: r.SkMemInfoSndBuf, + SkMemInfoSndbuf: r.SkMemInfoSndbuf, SkMemInfoFwdAlloc: r.SkMemInfoFwdAlloc, SkMemInfoWmemQueued: r.SkMemInfoWmemQueued, SkMemInfoOptmem: r.SkMemInfoOptmem, SkMemInfoBacklog: r.SkMemInfoBacklog, SkMemInfoDrops: r.SkMemInfoDrops, - ShutdownState: r.ShutdownState, + InetDiagShutdown: r.InetDiagShutdown, VegasInfoEnabled: r.VegasInfoEnabled, - VegasInfoRttCnt: r.VegasInfoRttCnt, + VegasInfoRttcnt: r.VegasInfoRttcnt, VegasInfoRtt: r.VegasInfoRtt, - VegasInfoMinRtt: r.VegasInfoMinRtt, + VegasInfoMinrtt: r.VegasInfoMinrtt, DctcpInfoEnabled: r.DctcpInfoEnabled, DctcpInfoCeState: r.DctcpInfoCeState, @@ -886,9 +924,9 @@ func rowFromProto(r *xtcp_flat_record.XtcpFlatRecord) ParquetRow { BbrInfoPacingGain: r.BbrInfoPacingGain, BbrInfoCwndGain: r.BbrInfoCwndGain, - ClassId: r.ClassId, - SockOpt: r.SockOpt, - CGroup: r.CGroup, + InetDiagClassId: r.InetDiagClassId, + InetDiagSockopt: r.InetDiagSockopt, + InetDiagCgroupId: r.InetDiagCgroupId, } } diff --git a/pkg/xtcp/destinations_s3parquet_schema.go b/pkg/xtcp/destinations_s3parquet_schema.go index ecdcd89..696c398 100644 --- a/pkg/xtcp/destinations_s3parquet_schema.go +++ b/pkg/xtcp/destinations_s3parquet_schema.go @@ -2,10 +2,12 @@ package xtcp -// ParquetRow mirrors xtcp_flat_record.v1.XtcpFlatRecord one-to-one. Each -// proto field becomes one Parquet column, named via the `parquet:` tag -// using the proto field's snake_case name (NOT the Go field's PascalCase) -// so SQL on the Parquet files matches SQL on the ClickHouse table. +// ParquetRow mirrors xtcp_flat_record.v1.XtcpFlatRecord one-to-one, in proto +// DECLARATION ORDER. Each proto field becomes one Parquet column, named via +// the `parquet:` tag using the proto field's snake_case name (NOT the Go +// field's PascalCase) so SQL on the Parquet files matches SQL on the +// ClickHouse table. Go field names follow the generated proto Go names so +// rowFromProto reads as a straight copy. // // Compression strategy mirrors the ClickHouse codec choices in // build/containers/clickhouse/initdb.d/sql/xtcp_xtcp_flat_records.sql: @@ -18,64 +20,119 @@ package xtcp // xtcp_flat_record.XtcpFlatRecord's proto descriptor. If you add a field // to the proto, that test fails until you mirror it here. The sole exception // is the derived event_date column (allowlisted in that test). +// +// Schema evolution: a proto field RENAME renames the Parquet column and ships +// as a schema_version bump (see pkg/xtcp/schema_version.go); readers spanning +// epochs branch on schema_version. See docs/parquet-format.md. type ParquetRow struct { - TimestampNs int64 `parquet:"timestamp_ns,snappy"` + // ---- metadata: record format provenance (1-2) + SchemaVersion uint32 `parquet:"schema_version,snappy"` + DaemonVersion string `parquet:"daemon_version,zstd"` - Hostname string `parquet:"hostname,zstd"` - Location string `parquet:"location,zstd"` + // ---- metadata: time (10) + TimestampNs int64 `parquet:"timestamp_ns,snappy"` // event_date: derived, not a proto field. Per-row UTC date of timestamp_ns, // named event_date (not date) to avoid the hive path-segment collision. EventDate string `parquet:"event_date,zstd"` - Netns string `parquet:"netns,zstd"` - NetnsInode uint64 `parquet:"netns_inode,snappy"` + // ---- metadata: host identity (20s) + Hostname string `parquet:"hostname,zstd"` + Location string `parquet:"location,zstd"` + + // ---- metadata: network namespace identity (30s) + Netns string `parquet:"netns,zstd"` + NetnsInode uint64 `parquet:"netns_inode,snappy"` + Nsid uint32 `parquet:"nsid,snappy"` + + // ---- metadata: container identity (40s) ContainerId string `parquet:"container_id,zstd"` ContainerRuntime string `parquet:"container_runtime,zstd"` - Nsid uint32 `parquet:"nsid,snappy"` + ContainerName string `parquet:"container_name,zstd"` + ContainerImage string `parquet:"container_image,zstd"` + // ---- metadata: free-form labels (50s) Label string `parquet:"label,zstd"` Tag string `parquet:"tag,zstd"` + // ---- metadata: record bookkeeping (60s) RecordCounter uint64 `parquet:"record_counter,snappy"` SocketFd uint64 `parquet:"socket_fd,snappy"` NetlinkerId uint64 `parquet:"netlinker_id,snappy"` - InetDiagMsgFamily uint32 `parquet:"inet_diag_msg_family,snappy"` - InetDiagMsgState uint32 `parquet:"inet_diag_msg_state,snappy"` - InetDiagMsgTimer uint32 `parquet:"inet_diag_msg_timer,snappy"` - InetDiagMsgRetrans uint32 `parquet:"inet_diag_msg_retrans,snappy"` - InetDiagMsgSocketSourcePort uint32 `parquet:"inet_diag_msg_socket_source_port,snappy"` - InetDiagMsgSocketDestinationPort uint32 `parquet:"inet_diag_msg_socket_destination_port,snappy"` - InetDiagMsgSocketSource []byte `parquet:"inet_diag_msg_socket_source,zstd"` - InetDiagMsgSocketDestination []byte `parquet:"inet_diag_msg_socket_destination,zstd"` - InetDiagMsgSocketInterface uint32 `parquet:"inet_diag_msg_socket_interface,snappy"` - InetDiagMsgSocketCookie uint64 `parquet:"inet_diag_msg_socket_cookie,snappy"` - InetDiagMsgSocketDestAsn uint64 `parquet:"inet_diag_msg_socket_dest_asn,snappy"` - InetDiagMsgSocketNextHopAsn uint64 `parquet:"inet_diag_msg_socket_next_hop_asn,snappy"` - InetDiagMsgSocketDestNetworkOwner string `parquet:"inet_diag_msg_socket_dest_network_owner,snappy"` - InetDiagMsgSocketDestLocality int32 `parquet:"inet_diag_msg_socket_dest_locality,snappy"` - InetDiagMsgExpires uint32 `parquet:"inet_diag_msg_expires,snappy"` - InetDiagMsgRqueue uint32 `parquet:"inet_diag_msg_rqueue,snappy"` - InetDiagMsgWqueue uint32 `parquet:"inet_diag_msg_wqueue,snappy"` - InetDiagMsgUid uint32 `parquet:"inet_diag_msg_uid,snappy"` - InetDiagMsgInode uint32 `parquet:"inet_diag_msg_inode,snappy"` - + // ---- metadata: host network topology, uplink slot 1 (100s) + Uplink1Ifname string `parquet:"uplink1_ifname,zstd"` + Uplink1NicDriver string `parquet:"uplink1_nic_driver,zstd"` + Uplink1NicModel string `parquet:"uplink1_nic_model,zstd"` + Uplink1NicPciVendor uint32 `parquet:"uplink1_nic_pci_vendor,snappy"` + Uplink1NicPciDevice uint32 `parquet:"uplink1_nic_pci_device,snappy"` + Uplink1NicBusInfo string `parquet:"uplink1_nic_bus_info,zstd"` + Uplink1NicSpeedMbps uint32 `parquet:"uplink1_nic_speed_mbps,snappy"` + Uplink1NicFwVersion string `parquet:"uplink1_nic_fw_version,zstd"` + Uplink1LldpChassisName string `parquet:"uplink1_lldp_chassis_name,zstd"` + Uplink1LldpChassisId string `parquet:"uplink1_lldp_chassis_id,zstd"` + Uplink1LldpMgmtIp string `parquet:"uplink1_lldp_mgmt_ip,zstd"` + Uplink1LldpPortId string `parquet:"uplink1_lldp_port_id,zstd"` + Uplink1LldpPortDescr string `parquet:"uplink1_lldp_port_descr,zstd"` + + // ---- metadata: host network topology, uplink slot 2 (200s) + Uplink2Ifname string `parquet:"uplink2_ifname,zstd"` + Uplink2NicDriver string `parquet:"uplink2_nic_driver,zstd"` + Uplink2NicModel string `parquet:"uplink2_nic_model,zstd"` + Uplink2NicPciVendor uint32 `parquet:"uplink2_nic_pci_vendor,snappy"` + Uplink2NicPciDevice uint32 `parquet:"uplink2_nic_pci_device,snappy"` + Uplink2NicBusInfo string `parquet:"uplink2_nic_bus_info,zstd"` + Uplink2NicSpeedMbps uint32 `parquet:"uplink2_nic_speed_mbps,snappy"` + Uplink2NicFwVersion string `parquet:"uplink2_nic_fw_version,zstd"` + Uplink2LldpChassisName string `parquet:"uplink2_lldp_chassis_name,zstd"` + Uplink2LldpChassisId string `parquet:"uplink2_lldp_chassis_id,zstd"` + Uplink2LldpMgmtIp string `parquet:"uplink2_lldp_mgmt_ip,zstd"` + Uplink2LldpPortId string `parquet:"uplink2_lldp_port_id,zstd"` + Uplink2LldpPortDescr string `parquet:"uplink2_lldp_port_descr,zstd"` + + // ---- enrichment: daemon-computed (300-399) + EnrichSocketInterfaceName string `parquet:"enrich_socket_interface_name,zstd"` + EnrichSocketDestLocality int32 `parquet:"enrich_socket_dest_locality,snappy"` + EnrichSocketDestEgressIfindex uint32 `parquet:"enrich_socket_dest_egress_ifindex,snappy"` + EnrichSocketDestEgressIfname string `parquet:"enrich_socket_dest_egress_ifname,zstd"` + EnrichSocketDestAsn uint64 `parquet:"enrich_socket_dest_asn,snappy"` + EnrichSocketDestNextHopAsn uint64 `parquet:"enrich_socket_dest_next_hop_asn,snappy"` + EnrichSocketDestNetworkOwner string `parquet:"enrich_socket_dest_network_owner,zstd"` + + // ---- payload: struct inet_diag_msg (1000s) + InetDiagMsgFamily uint32 `parquet:"inet_diag_msg_family,snappy"` + InetDiagMsgState uint32 `parquet:"inet_diag_msg_state,snappy"` + InetDiagMsgTimer uint32 `parquet:"inet_diag_msg_timer,snappy"` + InetDiagMsgRetrans uint32 `parquet:"inet_diag_msg_retrans,snappy"` + InetDiagMsgSocketSourcePort uint32 `parquet:"inet_diag_msg_socket_source_port,snappy"` + InetDiagMsgSocketDestinationPort uint32 `parquet:"inet_diag_msg_socket_destination_port,snappy"` + InetDiagMsgSocketSource []byte `parquet:"inet_diag_msg_socket_source,zstd"` + InetDiagMsgSocketDestination []byte `parquet:"inet_diag_msg_socket_destination,zstd"` + InetDiagMsgSocketInterface uint32 `parquet:"inet_diag_msg_socket_interface,snappy"` + InetDiagMsgSocketCookie uint64 `parquet:"inet_diag_msg_socket_cookie,snappy"` + InetDiagMsgExpires uint32 `parquet:"inet_diag_msg_expires,snappy"` + InetDiagMsgRqueue uint32 `parquet:"inet_diag_msg_rqueue,snappy"` + InetDiagMsgWqueue uint32 `parquet:"inet_diag_msg_wqueue,snappy"` + InetDiagMsgUid uint32 `parquet:"inet_diag_msg_uid,snappy"` + InetDiagMsgInode uint32 `parquet:"inet_diag_msg_inode,snappy"` + + // ---- payload: struct inet_diag_meminfo (1100s, deprecated) MemInfoRmem uint32 `parquet:"mem_info_rmem,snappy"` MemInfoWmem uint32 `parquet:"mem_info_wmem,snappy"` MemInfoFmem uint32 `parquet:"mem_info_fmem,snappy"` MemInfoTmem uint32 `parquet:"mem_info_tmem,snappy"` + // ---- payload: struct tcp_info (1200s) TcpInfoState uint32 `parquet:"tcp_info_state,snappy"` TcpInfoCaState uint32 `parquet:"tcp_info_ca_state,snappy"` TcpInfoRetransmits uint32 `parquet:"tcp_info_retransmits,snappy"` TcpInfoProbes uint32 `parquet:"tcp_info_probes,snappy"` TcpInfoBackoff uint32 `parquet:"tcp_info_backoff,snappy"` TcpInfoOptions uint32 `parquet:"tcp_info_options,snappy"` - TcpInfoSendScale uint32 `parquet:"tcp_info_send_scale,snappy"` - TcpInfoRcvScale uint32 `parquet:"tcp_info_rcv_scale,snappy"` + TcpInfoSndWscale uint32 `parquet:"tcp_info_snd_wscale,snappy"` + TcpInfoRcvWscale uint32 `parquet:"tcp_info_rcv_wscale,snappy"` TcpInfoDeliveryRateAppLimited uint32 `parquet:"tcp_info_delivery_rate_app_limited,snappy"` - TcpInfoFastOpenClientFailed uint32 `parquet:"tcp_info_fast_open_client_failed,snappy"` + TcpInfoFastopenClientFail uint32 `parquet:"tcp_info_fastopen_client_fail,snappy"` TcpInfoRto uint32 `parquet:"tcp_info_rto,snappy"` TcpInfoAto uint32 `parquet:"tcp_info_ato,snappy"` TcpInfoSndMss uint32 `parquet:"tcp_info_snd_mss,snappy"` @@ -92,10 +149,10 @@ type ParquetRow struct { TcpInfoPmtu uint32 `parquet:"tcp_info_pmtu,snappy"` TcpInfoRcvSsthresh uint32 `parquet:"tcp_info_rcv_ssthresh,snappy"` TcpInfoRtt uint32 `parquet:"tcp_info_rtt,snappy"` - TcpInfoRttVar uint32 `parquet:"tcp_info_rtt_var,snappy"` + TcpInfoRttvar uint32 `parquet:"tcp_info_rttvar,snappy"` TcpInfoSndSsthresh uint32 `parquet:"tcp_info_snd_ssthresh,snappy"` TcpInfoSndCwnd uint32 `parquet:"tcp_info_snd_cwnd,snappy"` - TcpInfoAdvMss uint32 `parquet:"tcp_info_adv_mss,snappy"` + TcpInfoAdvmss uint32 `parquet:"tcp_info_advmss,snappy"` TcpInfoReordering uint32 `parquet:"tcp_info_reordering,snappy"` TcpInfoRcvRtt uint32 `parquet:"tcp_info_rcv_rtt,snappy"` TcpInfoRcvSpace uint32 `parquet:"tcp_info_rcv_space,snappy"` @@ -106,7 +163,7 @@ type ParquetRow struct { TcpInfoBytesReceived uint64 `parquet:"tcp_info_bytes_received,snappy"` TcpInfoSegsOut uint32 `parquet:"tcp_info_segs_out,snappy"` TcpInfoSegsIn uint32 `parquet:"tcp_info_segs_in,snappy"` - TcpInfoNotSentBytes uint32 `parquet:"tcp_info_not_sent_bytes,snappy"` + TcpInfoNotsentBytes uint32 `parquet:"tcp_info_notsent_bytes,snappy"` TcpInfoMinRtt uint32 `parquet:"tcp_info_min_rtt,snappy"` TcpInfoDataSegsIn uint32 `parquet:"tcp_info_data_segs_in,snappy"` TcpInfoDataSegsOut uint32 `parquet:"tcp_info_data_segs_out,snappy"` @@ -128,44 +185,52 @@ type ParquetRow struct { TcpInfoTotalRtoRecoveries uint32 `parquet:"tcp_info_total_rto_recoveries,snappy"` TcpInfoTotalRtoTime uint32 `parquet:"tcp_info_total_rto_time,snappy"` - CongestionAlgorithmString string `parquet:"congestion_algorithm_string,zstd"` - CongestionAlgorithmEnum int32 `parquet:"congestion_algorithm_enum,snappy"` + // ---- payload: INET_DIAG_CONG (1300s) + InetDiagCong string `parquet:"inet_diag_cong,zstd"` + InetDiagCongEnum int32 `parquet:"inet_diag_cong_enum,snappy"` - TypeOfService uint32 `parquet:"type_of_service,snappy"` - TrafficClass uint32 `parquet:"traffic_class,snappy"` + // ---- payload: INET_DIAG_TOS / INET_DIAG_TCLASS (1400s) + InetDiagTos uint32 `parquet:"inet_diag_tos,snappy"` + InetDiagTclass uint32 `parquet:"inet_diag_tclass,snappy"` + // ---- payload: SK_MEMINFO_* (1500s) SkMemInfoRmemAlloc uint32 `parquet:"sk_mem_info_rmem_alloc,snappy"` - SkMemInfoRcvBuf uint32 `parquet:"sk_mem_info_rcv_buf,snappy"` + SkMemInfoRcvbuf uint32 `parquet:"sk_mem_info_rcvbuf,snappy"` SkMemInfoWmemAlloc uint32 `parquet:"sk_mem_info_wmem_alloc,snappy"` - SkMemInfoSndBuf uint32 `parquet:"sk_mem_info_snd_buf,snappy"` + SkMemInfoSndbuf uint32 `parquet:"sk_mem_info_sndbuf,snappy"` SkMemInfoFwdAlloc uint32 `parquet:"sk_mem_info_fwd_alloc,snappy"` SkMemInfoWmemQueued uint32 `parquet:"sk_mem_info_wmem_queued,snappy"` SkMemInfoOptmem uint32 `parquet:"sk_mem_info_optmem,snappy"` SkMemInfoBacklog uint32 `parquet:"sk_mem_info_backlog,snappy"` SkMemInfoDrops uint32 `parquet:"sk_mem_info_drops,snappy"` - ShutdownState uint32 `parquet:"shutdown_state,snappy"` + // ---- payload: INET_DIAG_SHUTDOWN (1600) + InetDiagShutdown uint32 `parquet:"inet_diag_shutdown,snappy"` + // ---- payload: struct tcpvegas_info (1700s) VegasInfoEnabled uint32 `parquet:"vegas_info_enabled,snappy"` - VegasInfoRttCnt uint32 `parquet:"vegas_info_rtt_cnt,snappy"` + VegasInfoRttcnt uint32 `parquet:"vegas_info_rttcnt,snappy"` VegasInfoRtt uint32 `parquet:"vegas_info_rtt,snappy"` - VegasInfoMinRtt uint32 `parquet:"vegas_info_min_rtt,snappy"` + VegasInfoMinrtt uint32 `parquet:"vegas_info_minrtt,snappy"` + // ---- payload: struct tcp_dctcp_info (1800s) DctcpInfoEnabled uint32 `parquet:"dctcp_info_enabled,snappy"` DctcpInfoCeState uint32 `parquet:"dctcp_info_ce_state,snappy"` DctcpInfoAlpha uint32 `parquet:"dctcp_info_alpha,snappy"` DctcpInfoAbEcn uint32 `parquet:"dctcp_info_ab_ecn,snappy"` DctcpInfoAbTot uint32 `parquet:"dctcp_info_ab_tot,snappy"` + // ---- payload: struct tcp_bbr_info (1900s) BbrInfoBwLo uint32 `parquet:"bbr_info_bw_lo,snappy"` BbrInfoBwHi uint32 `parquet:"bbr_info_bw_hi,snappy"` BbrInfoMinRtt uint32 `parquet:"bbr_info_min_rtt,snappy"` BbrInfoPacingGain uint32 `parquet:"bbr_info_pacing_gain,snappy"` BbrInfoCwndGain uint32 `parquet:"bbr_info_cwnd_gain,snappy"` - ClassId uint32 `parquet:"class_id,snappy"` - SockOpt uint32 `parquet:"sock_opt,snappy"` - CGroup uint64 `parquet:"c_group,snappy"` + // ---- payload: INET_DIAG_CLASS_ID / SOCKOPT / CGROUP_ID (2000s) + InetDiagClassId uint32 `parquet:"inet_diag_class_id,snappy"` + InetDiagSockopt uint32 `parquet:"inet_diag_sockopt,snappy"` + InetDiagCgroupId uint64 `parquet:"inet_diag_cgroup_id,snappy"` } // The rowFromProto conversion function lives in diff --git a/pkg/xtcp/destinations_s3parquet_schema_test.go b/pkg/xtcp/destinations_s3parquet_schema_test.go index 12221a9..0af091b 100644 --- a/pkg/xtcp/destinations_s3parquet_schema_test.go +++ b/pkg/xtcp/destinations_s3parquet_schema_test.go @@ -139,7 +139,11 @@ func TestS3ParquetSchema_columnTypes(t *testing.T) { {"inet_diag_msg_socket_source", parquet.ByteArray}, {"nsid", parquet.Int32}, {"socket_fd", parquet.Int64}, - {"congestion_algorithm_enum", parquet.Int32}, + {"inet_diag_cong_enum", parquet.Int32}, + {"enrich_socket_dest_locality", parquet.Int32}, + {"inet_diag_cgroup_id", parquet.Int64}, + {"schema_version", parquet.Int32}, + {"uplink1_ifname", parquet.ByteArray}, } for _, tc := range cases { tc := tc diff --git a/pkg/xtcp/dispatch_test.go b/pkg/xtcp/dispatch_test.go index 1ad2491..49f9cbe 100644 --- a/pkg/xtcp/dispatch_test.go +++ b/pkg/xtcp/dispatch_test.go @@ -260,8 +260,8 @@ func TestZeroXTCPCongRecord_dispatch(t *testing.T) { // A record with BBR1 cong algo + non-zero BBR fields should have // those fields zeroed. rec := &xtcp_flat_record.XtcpFlatRecord{ - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR1, - BbrInfoBwLo: 123456, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR1, + BbrInfoBwLo: 123456, } x.ZeroXTCPCongRecord(rec) if rec.BbrInfoBwLo != 0 { @@ -279,8 +279,8 @@ func TestZeroXTCPCongRecord_dctcp(t *testing.T) { x.InitZeroizers(&wg) wg.Wait() rec := &xtcp_flat_record.XtcpFlatRecord{ - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_DCTCP, - DctcpInfoCeState: 12, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_DCTCP, + DctcpInfoCeState: 12, } x.ZeroXTCPCongRecord(rec) if rec.DctcpInfoCeState != 0 { @@ -295,8 +295,8 @@ func TestZeroXTCPCongRecord_vegas(t *testing.T) { x.InitZeroizers(&wg) wg.Wait() rec := &xtcp_flat_record.XtcpFlatRecord{ - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_VEGAS, - VegasInfoEnabled: 7, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_VEGAS, + VegasInfoEnabled: 7, } x.ZeroXTCPCongRecord(rec) if rec.VegasInfoEnabled != 0 { @@ -312,8 +312,8 @@ func TestZeroXTCPCongRecord_unknownCong(t *testing.T) { wg.Wait() // An unknown cong algorithm should be a no-op (no panic, no mutation). rec := &xtcp_flat_record.XtcpFlatRecord{ - CongestionAlgorithmEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_UNSPECIFIED, - BbrInfoBwLo: 123456, + InetDiagCongEnum: xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_UNSPECIFIED, + BbrInfoBwLo: 123456, } x.ZeroXTCPCongRecord(rec) if rec.BbrInfoBwLo != 123456 { diff --git a/pkg/xtcp/enrich.go b/pkg/xtcp/enrich.go index 2b2ea7b..4eeebe1 100644 --- a/pkg/xtcp/enrich.go +++ b/pkg/xtcp/enrich.go @@ -13,7 +13,6 @@ import ( "github.com/randomizedcoder/xtcp2/pkg/dockermeta" "github.com/randomizedcoder/xtcp2/pkg/ipasn" "github.com/randomizedcoder/xtcp2/pkg/lldp" - "github.com/randomizedcoder/xtcp2/pkg/localnet" "github.com/randomizedcoder/xtcp2/pkg/nicinfo" "github.com/randomizedcoder/xtcp2/pkg/nsdiscover" ) @@ -104,12 +103,25 @@ func (x *XTCP) initEnrichers(ctx context.Context) { x.initLocalityEnricher() } -// initAsnEnricher loads the ipfeed-collector Parquet artifact into an in-process -// longest-prefix-match trie for destination IP -> {ASN, network owner}. A -// load failure disables ASN enrichment (counter + log) without touching the -// rest of the daemon. When asn_refresh_interval > 0 a background goroutine -// reloads the artifact so a refreshed file is picked up without a restart; a -// failed reload leaves the in-service trie untouched. +// initAsnEnricher wires destination IP -> {ASN, network owner} enrichment from +// the ipfeed-collector Parquet artifact (pkg/ipasn, an in-process +// longest-prefix-match trie). +// +// The index is always created and the first load attempted; the outcome only +// decides how failure is handled: +// - load ok: enrichment is live, and when asn_refresh_interval > 0 a +// background goroutine re-stats the file every interval and rebuilds the +// trie only when its size/mtime changed (ipasn.ReloadIfChanged); +// - load failed, interval > 0: the (empty) index is still installed and the +// same goroutine retries on every tick, so an artifact that arrives after +// the daemon started — or a refreshed one — is picked up without a restart; +// lookups miss until then; +// - load failed, interval <= 0: nothing would ever load, so enrichment stays +// disabled (asnIndex nil) exactly as before. +// +// A failed reload never touches the trie in service. Outcomes are counted +// under function="initEnrichers"/"refreshAsn"; the table itself (entries, +// artifact size, load time, build duration) is published by loadAsn. func (x *XTCP) initAsnEnricher(ctx context.Context) { if !x.config.EnrichAsnEnable { return @@ -120,40 +132,93 @@ func (x *XTCP) initAsnEnricher(ctx context.Context) { log.Printf("initAsnEnricher: ASN enrichment disabled (best-effort): asn_db_path is empty") return } + interval := x.config.GetAsnRefreshInterval().AsDuration() - idx, err := ipasn.New(path) - if err != nil { + idx := &ipasn.Index{} + if _, err := x.loadAsn(idx, path, true); err != nil { x.pC.WithLabelValues("initEnrichers", "asn", "error").Inc() - log.Printf("initAsnEnricher: ASN enrichment disabled (best-effort): %v", err) - return + if interval <= 0 { + log.Printf("initAsnEnricher: ASN enrichment disabled (best-effort, asn_refresh_interval is 0 so it will not retry): %v", err) + return + } + log.Printf("initAsnEnricher: ASN artifact not loaded (will retry every %s; lookups miss until then): %v", interval, err) + } else { + x.pC.WithLabelValues("initEnrichers", "asn", "enabled").Inc() + if x.debugLevel > 10 { + log.Printf("initAsnEnricher: ASN enrichment enabled (db:%s prefixes:%d)", path, idx.Len()) + } } x.asnIndex = idx - x.pC.WithLabelValues("initEnrichers", "asn", "enabled").Inc() - if x.debugLevel > 10 { - log.Printf("initAsnEnricher: ASN enrichment enabled (db:%s)", path) - } - interval := x.config.GetAsnRefreshInterval().AsDuration() if interval <= 0 { return // load-once; no background refresh } - go func() { - ticker := time.NewTicker(interval) - defer ticker.Stop() - for { - select { - case <-ctx.Done(): - return - case <-ticker.C: - if err := idx.Reload(path); err != nil { - x.pC.WithLabelValues("refreshAsn", "reload", "error").Inc() - log.Printf("initAsnEnricher: ASN reload failed (keeping current table): %v", err) - continue - } + go x.refreshAsn(ctx, idx, path, interval) +} + +// refreshAsn is initAsnEnricher's background loop: every interval it asks the +// index to reload path if the file changed (or was never loaded). Runs until +// ctx is cancelled. +func (x *XTCP) refreshAsn(ctx context.Context, idx *ipasn.Index, path string, interval time.Duration) { + ticker := time.NewTicker(interval) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + reloaded, err := x.loadAsn(idx, path, false) + switch { + case err != nil: + x.pC.WithLabelValues("refreshAsn", "reload", "error").Inc() + log.Printf("initAsnEnricher: ASN reload failed (keeping current table): %v", err) + case !reloaded: + x.pC.WithLabelValues("refreshAsn", "reload", "unchanged").Inc() + default: x.pC.WithLabelValues("refreshAsn", "reload", "ok").Inc() + if x.debugLevel > 10 { + log.Printf("initAsnEnricher: ASN artifact reloaded (db:%s prefixes:%d)", path, idx.Len()) + } } } - }() + } +} + +// loadAsn runs one load attempt against idx — forced (start-up) or stat-gated +// (refresh tick) — and publishes what an operator needs to see about the ASN +// lookup table, all under function="loadAsn" so the start-up load and every +// refresh land on the same series: +// +// - gauges prefixes (entries in the trie in service), artifactBytes (size of +// the Parquet file it was built from) and loadedAt (unix seconds of the +// last successful load, so `time() - loadedAt` is the table's age); +// - summary build/duration — read + trie build of a successful load — and +// error/duration — how long a failed attempt took before giving up. +// +// A stat-gated attempt that finds the artifact unchanged publishes nothing: the +// gauges already describe the table in service. The bool reports whether a +// new table was swapped in. +func (x *XTCP) loadAsn(idx *ipasn.Index, path string, force bool) (reloaded bool, err error) { + start := time.Now() + if force { + err = idx.Reload(path) + reloaded = err == nil + } else { + reloaded, err = idx.ReloadIfChanged(path) + } + if err != nil { + x.pH.WithLabelValues("loadAsn", "error", "duration").Observe(time.Since(start).Seconds()) + return false, err + } + if !reloaded { + return false, nil + } + st := idx.Stats() + x.pGV.WithLabelValues("loadAsn", "prefixes", "gauge").Set(float64(st.Prefixes)) + x.pGV.WithLabelValues("loadAsn", "artifactBytes", "gauge").Set(float64(st.ArtifactBytes)) + x.pGV.WithLabelValues("loadAsn", "loadedAt", "gauge").Set(float64(st.LoadedAt.Unix())) + x.pH.WithLabelValues("loadAsn", "build", "duration").Observe(st.BuildDuration.Seconds()) + return true, nil } // initDockerEnricher builds the netns-inode -> container index over the Docker @@ -303,24 +368,36 @@ func (x *XTCP) applyEnrichment(r *xtcp_flat_record.XtcpFlatRecord) { } } + // Neither destination enricher enabled (no ASN index, no locality snapshot + // ever published): skip the address conversion so disabled mode is a true + // no-op on the hot path. + if x.asnIndex == nil && x.localityByInode.Load() == nil { + return + } + if addr, ok := destAddr(r.InetDiagMsgFamily, r.InetDiagMsgSocketDestination); ok { // Classify the destination's locality first. remote defaults to true so // that with locality disabled (nil map) or no snapshot for this namespace // the ASN lookup runs exactly as before. A self / connected-subnet - // destination is tagged and skips the internet ASN feed. + // destination is tagged and skips the internet ASN feed. The same snapshot + // resolves the destination's egress interface (from the matched route's + // Oif) and the socket's own bound interface (kernel idiag_if, field 1009). remote := true if m := x.localityByInode.Load(); m != nil { if snap := (*m)[r.NetnsInode]; snap != nil { - loc := snap.Classify(addr) - r.InetDiagMsgSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(loc) - remote = loc == localnet.LocalityRemote + res := snap.Resolve(addr, r.InetDiagMsgSocketInterface) + r.EnrichSocketDestLocality = xtcp_flat_record.XtcpFlatRecord_Locality(res.Locality) + r.EnrichSocketDestEgressIfindex = res.EgressIfindex + r.EnrichSocketDestEgressIfname = res.EgressIfname + r.EnrichSocketInterfaceName = res.BoundIfname + remote = res.Remote } } if remote && x.asnIndex != nil { if a, found := x.asnIndex.Lookup(addr); found { - r.InetDiagMsgSocketDestAsn = uint64(a.ASN) - r.InetDiagMsgSocketDestNetworkOwner = a.NetworkOwner + r.EnrichSocketDestAsn = uint64(a.ASN) + r.EnrichSocketDestNetworkOwner = a.NetworkOwner } } } diff --git a/pkg/xtcp/enrich_asn_test.go b/pkg/xtcp/enrich_asn_test.go new file mode 100644 index 0000000..fd2d6ef --- /dev/null +++ b/pkg/xtcp/enrich_asn_test.go @@ -0,0 +1,304 @@ +package xtcp + +import ( + "context" + "net/netip" + "os" + "path/filepath" + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/testutil" + dto "github.com/prometheus/client_model/go" + "google.golang.org/protobuf/types/known/durationpb" + + "github.com/randomizedcoder/xtcp2/gen/go/xtcp_config" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/model" + "github.com/randomizedcoder/xtcp2/internal/ipfeed/output" + "github.com/randomizedcoder/xtcp2/pkg/ipasn" +) + +// ---- initAsnEnricher -------------------------------------------------------- +// +// Drives the ASN enricher's start-up and refresh decisions against real Parquet +// artifacts written with the collector's own writer, with a short refresh +// interval so the background loop is observed within the test. + +var ( + asnRowsA = []model.Record{ + {Prefix: "1.1.1.0/24", IPVersion: 4, ASN: 13335, NetworkOwner: "cloudflare"}, + {Prefix: "8.8.8.0/24", IPVersion: 4, ASN: 15169, NetworkOwner: "google"}, + } + asnRowsB = []model.Record{ + {Prefix: "1.1.1.0/24", IPVersion: 4, ASN: 1, NetworkOwner: "replaced-owner"}, + } +) + +func writeAsnArtifact(t *testing.T, path string, rows []model.Record) { + t.Helper() + if _, err := output.WriteParquet(path, rows); err != nil { + t.Fatalf("WriteParquet(%s): %v", path, err) + } +} + +// waitFor polls cond until it is true or the deadline passes. +func waitFor(t *testing.T, what string, cond func() bool) { + t.Helper() + deadline := time.Now().Add(3 * time.Second) + for time.Now().Before(deadline) { + if cond() { + return + } + time.Sleep(5 * time.Millisecond) + } + t.Fatalf("timed out waiting for %s", what) +} + +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestInitAsnEnricher +func TestInitAsnEnricher(t *testing.T) { + const tick = 20 * time.Millisecond + + tests := []struct { + description string + enable bool + pathMode string // "valid" | "missing" | "empty" | "corrupt" + interval time.Duration + wantIndex bool // x.asnIndex != nil after init + wantOwner string // owner of 1.1.1.1 right after init ("" = miss) + // after is an optional second phase exercising the refresh loop. + after func(t *testing.T, x *XTCP, path string) + }{ + // positive + {"enabled, valid artifact, interval 0 -> index live, no refresh", true, "valid", 0, true, "cloudflare", nil}, + {"enabled, valid artifact, refresh on -> index live", true, "valid", tick, true, "cloudflare", nil}, + {"refresh picks up a rewritten artifact", true, "valid", tick, true, "cloudflare", + func(t *testing.T, x *XTCP, path string) { + // Make sure the mtime differs from the first write even on coarse filesystems. + time.Sleep(15 * time.Millisecond) + writeAsnArtifact(t, path, asnRowsB) + waitFor(t, "reload of the rewritten artifact", func() bool { + a, ok := x.asnIndex.Lookup(netip.MustParseAddr("1.1.1.1")) + return ok && a.NetworkOwner == "replaced-owner" + }) + if _, ok := x.asnIndex.Lookup(netip.MustParseAddr("8.8.8.8")); ok { + t.Error("old prefix still present after reload (table not swapped atomically)") + } + }}, + {"unchanged artifact is not rebuilt on the tick (stat short-circuit)", true, "valid", tick, true, "cloudflare", + func(t *testing.T, x *XTCP, _ string) { + waitFor(t, "a few refresh ticks", func() bool { + return testutil.ToFloat64(x.pC.WithLabelValues("refreshAsn", "reload", "unchanged")) >= 3 + }) + if ok := testutil.ToFloat64(x.pC.WithLabelValues("refreshAsn", "reload", "ok")); ok != 0 { + t.Errorf("reload/ok = %v on an unchanged file, want 0", ok) + } + }}, + + // negative + {"disabled -> no index", false, "valid", tick, false, "", nil}, + {"enabled but asn_db_path empty -> no index", true, "empty", tick, false, "", nil}, + {"enabled, missing artifact, interval 0 -> disabled (nothing would ever retry)", true, "missing", 0, false, "", nil}, + {"enabled, corrupt artifact, interval 0 -> disabled", true, "corrupt", 0, false, "", nil}, + + // corner — retry armed although the first load failed + {"enabled, missing artifact, refresh on -> empty index installed, loads once the file appears", true, "missing", tick, true, "", + func(t *testing.T, x *XTCP, path string) { + waitFor(t, "at least one failed reload attempt", func() bool { + return testutil.ToFloat64(x.pC.WithLabelValues("refreshAsn", "reload", "error")) >= 1 + }) + writeAsnArtifact(t, path, asnRowsA) + waitFor(t, "late-arriving artifact to load", func() bool { + a, ok := x.asnIndex.Lookup(netip.MustParseAddr("1.1.1.1")) + return ok && a.NetworkOwner == "cloudflare" + }) + }}, + {"a bad refresh keeps the table in service", true, "valid", tick, true, "cloudflare", + func(t *testing.T, x *XTCP, path string) { + time.Sleep(15 * time.Millisecond) + writeAsnArtifact(t, path, nil) // zero-row artifact -> ErrNoPrefixes on reload + waitFor(t, "the failed reload to be counted", func() bool { + return testutil.ToFloat64(x.pC.WithLabelValues("refreshAsn", "reload", "error")) >= 1 + }) + if a, ok := x.asnIndex.Lookup(netip.MustParseAddr("1.1.1.1")); !ok || a.NetworkOwner != "cloudflare" { + t.Errorf("table degraded after failed reload: (%+v,%v)", a, ok) + } + }}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + x := newLocalityFixture(t, time.Minute) + dir := t.TempDir() + path := filepath.Join(dir, "feeds.parquet") + switch tc.pathMode { + case "valid": + writeAsnArtifact(t, path, asnRowsA) + case "corrupt": + writeBytesFile(t, path, []byte("not parquet")) + case "empty": + path = "" + case "missing": + // leave absent + } + x.config = &xtcp_config.XtcpConfig{ + EnrichAsnEnable: tc.enable, + AsnDbPath: path, + AsnRefreshInterval: durationpb.New(tc.interval), + } + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + + x.initAsnEnricher(ctx) + + if (x.asnIndex != nil) != tc.wantIndex { + t.Fatalf("asnIndex != nil = %v, want %v", x.asnIndex != nil, tc.wantIndex) + } + if x.asnIndex != nil { + a, ok := x.asnIndex.Lookup(netip.MustParseAddr("1.1.1.1")) + if got := ownerOrEmpty(a.NetworkOwner, ok); got != tc.wantOwner { + t.Errorf("Lookup(1.1.1.1) owner = %q, want %q", got, tc.wantOwner) + } + } + if tc.after != nil { + tc.after(t, x, path) + } + }) + } +} + +// ---- loadAsn metrics ---------------------------------------------------------- +// +// The lookup table's operational metrics live under function="loadAsn": +// gauges prefixes / artifactBytes / loadedAt and the build / error duration +// summaries. These rows drive loadAsn directly (no ticker) so each outcome is +// observed deterministically. + +// summaryCount returns the sample count of the pH summary at (function, variable). +func summaryCount(t *testing.T, x *XTCP, function, variable string) uint64 { + t.Helper() + m := &dto.Metric{} + obs, ok := x.pH.WithLabelValues(function, variable, "duration").(prometheus.Metric) + if !ok { + t.Fatalf("pH observer for %s/%s is not a prometheus.Metric", function, variable) + } + if err := obs.Write(m); err != nil { + t.Fatalf("Write summary %s/%s: %v", function, variable, err) + } + return m.GetSummary().GetSampleCount() +} + +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestLoadAsnMetrics +func TestLoadAsnMetrics(t *testing.T) { + tests := []struct { + description string + // prime, when set, is run first with force=true against a valid artifact + // so the row starts from a populated table. + prime bool + // pathMode picks what the measured loadAsn call sees. + pathMode string // "valid" | "rewritten" | "missing" | "corrupt" | "zeroRow" + force bool + + wantReloaded bool + wantErr bool + wantPrefixes float64 // loadAsn/prefixes gauge afterwards + wantBytesPos bool // loadAsn/artifactBytes gauge > 0 + wantLoadedAt bool // loadAsn/loadedAt gauge > 0 + wantBuildCount uint64 // loadAsn/build duration samples + wantErrCount uint64 // loadAsn/error duration samples + }{ + // positive + {"forced start-up load of a valid artifact publishes the table size and one build sample", + false, "valid", true, true, false, 2, true, true, 1, 0}, + {"stat-gated load on an empty index still loads (zero index always loads)", + false, "valid", false, true, false, 2, true, true, 1, 0}, + {"rewritten artifact on the refresh path moves the gauge and adds a build sample", + true, "rewritten", false, true, false, 1, true, true, 2, 0}, + // corner — nothing to do + {"unchanged artifact on the refresh path: no new build sample, gauges as before", + true, "valid", false, false, false, 2, true, true, 1, 0}, + // negative — failures leave the published table alone + {"missing artifact on start-up: error sample, gauges stay 0", + false, "missing", true, false, true, 0, false, false, 0, 1}, + {"corrupt artifact on start-up: error sample, gauges stay 0", + false, "corrupt", true, false, true, 0, false, false, 0, 1}, + {"zero-row artifact on the refresh path keeps the good table's gauges and counts the error", + true, "zeroRow", false, false, true, 2, true, true, 1, 1}, + {"artifact deleted between ticks keeps the good table's gauges and counts the error", + true, "missing", false, false, true, 2, true, true, 1, 1}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + x := newLocalityFixture(t, time.Minute) + path := filepath.Join(t.TempDir(), "feeds.parquet") + idx := &ipasn.Index{} + if tc.prime { + writeAsnArtifact(t, path, asnRowsA) + if _, err := x.loadAsn(idx, path, true); err != nil { + t.Fatalf("prime load: %v", err) + } + } + switch tc.pathMode { + case "valid": + if !tc.prime { + writeAsnArtifact(t, path, asnRowsA) + } + case "rewritten": + time.Sleep(15 * time.Millisecond) // distinct mtime on coarse filesystems + writeAsnArtifact(t, path, asnRowsB) + case "missing": + _ = os.Remove(path) + case "corrupt": + writeBytesFile(t, path, []byte("not parquet")) + case "zeroRow": + time.Sleep(15 * time.Millisecond) + writeAsnArtifact(t, path, nil) + } + + reloaded, err := x.loadAsn(idx, path, tc.force) + if reloaded != tc.wantReloaded { + t.Errorf("reloaded = %v, want %v", reloaded, tc.wantReloaded) + } + if (err != nil) != tc.wantErr { + t.Errorf("err = %v, wantErr %v", err, tc.wantErr) + } + + gauge := func(variable string) float64 { + return testutil.ToFloat64(x.pGV.WithLabelValues("loadAsn", variable, "gauge")) + } + if got := gauge("prefixes"); got != tc.wantPrefixes { + t.Errorf("loadAsn/prefixes gauge = %v, want %v", got, tc.wantPrefixes) + } + if got := gauge("artifactBytes"); (got > 0) != tc.wantBytesPos { + t.Errorf("loadAsn/artifactBytes gauge = %v, want >0: %v", got, tc.wantBytesPos) + } + if got := gauge("loadedAt"); (got > 0) != tc.wantLoadedAt { + t.Errorf("loadAsn/loadedAt gauge = %v, want >0: %v", got, tc.wantLoadedAt) + } + if got := summaryCount(t, x, "loadAsn", "build"); got != tc.wantBuildCount { + t.Errorf("loadAsn/build duration samples = %d, want %d", got, tc.wantBuildCount) + } + if got := summaryCount(t, x, "loadAsn", "error"); got != tc.wantErrCount { + t.Errorf("loadAsn/error duration samples = %d, want %d", got, tc.wantErrCount) + } + // The gauge must agree with the table actually answering lookups. + if st := idx.Stats(); float64(st.Prefixes) != gauge("prefixes") { + t.Errorf("gauge %v disagrees with idx.Stats().Prefixes %d", gauge("prefixes"), st.Prefixes) + } + }) + } +} + +func ownerOrEmpty(owner string, ok bool) string { + if !ok { + return "" + } + return owner +} + +func writeBytesFile(t *testing.T, path string, b []byte) { + t.Helper() + if err := os.WriteFile(path, b, 0o600); err != nil { + t.Fatal(err) + } +} diff --git a/pkg/xtcp/enrich_locality.go b/pkg/xtcp/enrich_locality.go index ef9ad6e..ce5a00e 100644 --- a/pkg/xtcp/enrich_locality.go +++ b/pkg/xtcp/enrich_locality.go @@ -1,6 +1,7 @@ package xtcp import ( + "errors" "log" "runtime" "time" @@ -16,6 +17,59 @@ import ( // blocking the reconcile owner. var localityRecvTimeout = unix.Timeval{Sec: 2} +const ( + // localityRetryMinCst / localityRetryMaxCst bound the per-namespace + // negative-cache backoff: the first hard failure (open/setns/dump error) + // waits 30s, doubling each further failure up to 5m. A loopback-only + // snapshot starts one notch earlier — it is re-dumped on the very next + // reconcile, then follows the same schedule if lo is still all there is. + localityRetryMinCst = 30 * time.Second + localityRetryMaxCst = 5 * time.Minute + + // localityNewNsPerPassCst caps how many namespaces a NON-full reconcile + // pass may dump (new namespaces plus expired retries). A container burst + // of hundreds of namespaces is then classified over a few reconciles + // instead of stalling one reconcile for every dump; the remainder are + // counted as deferred and picked up next pass. A full pass (every + // locality_refresh_interval) is uncapped — re-dumping everything is its + // job. + localityNewNsPerPassCst = 32 + + // localityDumpRetriesCst is how many times one rtnetlink dump is re-issued + // when the kernel flags NLM_F_DUMP_INTR (table changed mid-dump) before the + // whole namespace is treated as a failed dump for this pass. + localityDumpRetriesCst = 3 +) + +// localityRetryState is one namespace's negative-cache entry: when it may next +// be dumped and the backoff that produced that time (0 = "next pass"). +type localityRetryState struct { + nextRetry time.Time + backoff time.Duration +} + +// nextLocalityRetry computes the retry state after one unsuccessful dump. +// retrying says whether prev is a live entry (vs. the zero value for a +// namespace with no history); hard distinguishes a failed dump from a +// loopback-only snapshot, which is a softer signal (the namespace is fine, the +// veth just is not plumbed yet) and therefore gets one immediate re-dump before +// backing off. +func nextLocalityRetry(prev localityRetryState, retrying bool, now time.Time, hard bool) localityRetryState { + var b time.Duration + switch { + case !retrying && !hard: + b = 0 // first loopback-only sighting: again on the very next pass + case !retrying || prev.backoff == 0: + b = localityRetryMinCst + default: + b = prev.backoff * 2 + if b > localityRetryMaxCst { + b = localityRetryMaxCst + } + } + return localityRetryState{nextRetry: now.Add(b), backoff: b} +} + // initLocalityEnricher records that locality classification is enabled. The // actual per-namespace discovery is driven by the single-owner reconcile path // (refreshLocality, called from discoverNamespaces), so there is nothing to @@ -32,48 +86,143 @@ func (x *XTCP) initLocalityEnricher() { } } +// localityNow is the reconcile clock (time.Now unless a test injected one). +func (x *XTCP) localityNow() time.Time { + if x.localityClock != nil { + return x.localityClock() + } + return time.Now() +} + +// dumpLocality performs one namespace's discovery (nsLocalitySnapshot unless a +// test injected a dumper). +func (x *XTCP) dumpLocality(id nsIdentity) (*localnet.Snapshot, bool) { + if x.localityDumper != nil { + return x.localityDumper(id) + } + return x.nsLocalitySnapshot(id) +} + // refreshLocality rebuilds the netns-inode -> locality snapshot for the current // namespace set and publishes it atomically for the stamping path. It is called // only from the single-owner reconcile path (discoverNamespaces) under -// reconcileMu, so lastLocalityRefresh needs no additional lock. +// reconcileMu, so lastLocalityRefresh and localityRetry need no additional lock. +// +// Which namespaces get dumped on a pass: +// - a FULL pass (first ever, or locality_refresh_interval elapsed) re-dumps +// every namespace that is not sitting in a retry backoff, uncapped; +// - any other pass dumps only namespaces without a snapshot (new since last +// pass) and namespaces whose retry window has opened, at most +// localityNewNsPerPassCst of them — the rest are deferred to the next +// reconcile (they keep any previous snapshot meanwhile). +// +// What happens to a dump's outcome: +// - success with a non-loopback self address: published, retry state cleared; +// - success but loopback-only (container whose veth is not plumbed yet): the +// snapshot IS published (it classifies loopback correctly) and the +// namespace is re-dumped on the next pass, then on the 30s→5m schedule; +// - failure (open/setns/dump error): the previous snapshot is kept, and the +// namespace is retried on the 30s→5m schedule instead of every reconcile. // -// It is throttled by locality_refresh_interval: a "full" pass re-discovers every -// namespace, while intervening passes only discover namespaces that appeared -// since the last snapshot (so a new container is classified promptly without -// re-dumping every existing namespace every reconcile). A namespace whose -// discovery fails keeps its previous snapshot rather than dropping to -// unclassified. interval <= 0 means discover each namespace once and never -// refresh it (new namespaces are still picked up). +// Retry state for namespaces that vanished is dropped. interval <= 0 means +// there is never another full pass: each namespace is discovered once (plus +// its retries) and never refreshed. func (x *XTCP) refreshLocality(nss map[uint64]nsIdentity) { - now := time.Now() + start := x.localityNow() interval := x.config.GetLocalityRefreshInterval().AsDuration() - full := x.lastLocalityRefresh.IsZero() || (interval > 0 && now.Sub(x.lastLocalityRefresh) >= interval) + full := x.lastLocalityRefresh.IsZero() || (interval > 0 && start.Sub(x.lastLocalityRefresh) >= interval) var cur map[uint64]*localnet.Snapshot if p := x.localityByInode.Load(); p != nil { cur = *p } + if x.localityRetry == nil { + x.localityRetry = make(map[uint64]localityRetryState) + } + budget := localityNewNsPerPassCst + if full { + budget = -1 // uncapped + } + + var dumped, failed, loOnly, deferred, reused int m := make(map[uint64]*localnet.Snapshot, len(nss)) for inode, id := range nss { - if !full { - if snap, ok := cur[inode]; ok { - m[inode] = snap // reuse; between full passes only new namespaces are dumped - continue + prev, had := cur[inode] + retry, retrying := x.localityRetry[inode] + + need := full || !had + if retrying { + // Negative-cached: dump only once its window has opened, even on a + // full pass — a permanently failing namespace must not be hammered + // every refresh interval. + need = !start.Before(retry.nextRetry) + } + if !need { + if had { + m[inode] = prev + reused++ + } + continue + } + if budget == 0 { + deferred++ + if had { + m[inode] = prev } + continue } - if snap, ok := x.nsLocalitySnapshot(id); ok { + if budget > 0 { + budget-- + } + + snap, ok := x.dumpLocality(id) + dumped++ + switch { + case !ok: + failed++ + x.localityRetry[inode] = nextLocalityRetry(retry, retrying, start, true) + if had { + m[inode] = prev // keep the last good snapshot on a discovery failure + } + case !snap.HasNonLoopbackSelf(): + loOnly++ m[inode] = snap - } else if snap, had := cur[inode]; had { - m[inode] = snap // keep the last good snapshot on a discovery failure + x.localityRetry[inode] = nextLocalityRetry(retry, retrying, start, false) + default: + m[inode] = snap + delete(x.localityRetry, inode) + } + } + + for inode := range x.localityRetry { + if _, present := nss[inode]; !present { + delete(x.localityRetry, inode) } } x.localityByInode.Store(&m) if full { - x.lastLocalityRefresh = now + x.lastLocalityRefresh = start + } + + passType := "partial" + if full { + passType = "full" + } + x.pC.WithLabelValues("refreshLocality", passType, "count").Inc() + x.pC.WithLabelValues("refreshLocality", "dumped", "count").Add(float64(dumped)) + x.pC.WithLabelValues("refreshLocality", "failed", "count").Add(float64(failed)) + x.pC.WithLabelValues("refreshLocality", "loopbackOnly", "count").Add(float64(loOnly)) + x.pC.WithLabelValues("refreshLocality", "deferred", "count").Add(float64(deferred)) + x.pGV.WithLabelValues("refreshLocality", "namespaces", "gauge").Set(float64(len(m))) + x.pGV.WithLabelValues("refreshLocality", "retryBackoff", "gauge").Set(float64(len(x.localityRetry))) + x.pH.WithLabelValues("refreshLocality", passType, "duration").Observe(x.localityNow().Sub(start).Seconds()) + + if x.debugLevel > 10 { + log.Printf("refreshLocality: %s pass namespaces:%d dumped:%d reused:%d failed:%d loopbackOnly:%d deferred:%d inBackoff:%d took:%s", + passType, len(m), dumped, reused, failed, loOnly, deferred, len(x.localityRetry), x.localityNow().Sub(start)) } - x.pC.WithLabelValues("refreshLocality", "namespaces", "counter").Add(float64(len(m))) } // nsLocalitySnapshot enters the namespace referenced by id, dumps its links, @@ -82,8 +231,8 @@ func (x *XTCP) refreshLocality(nss map[uint64]nsIdentity) { // thread is netns-tainted, so on return the Go runtime terminates it instead of // recycling it — the same safety property netNamespaceInstance relies on to // avoid the tainted-M thread-exhaustion regression. These dumps are infrequent -// (throttled by locality_refresh_interval), so the per-call thread teardown is -// cheap. Best-effort: any error yields (nil, false). +// (throttled by locality_refresh_interval and the retry backoff), so the +// per-call thread teardown is cheap. Best-effort: any error yields (nil, false). func (x *XTCP) nsLocalitySnapshot(id nsIdentity) (*localnet.Snapshot, bool) { handle := id.path if handle == "" { @@ -159,57 +308,81 @@ func (x *XTCP) dumpLocalityInNs() (*localnet.Snapshot, error) { var seq uint32 - // Links: traverse for a per-namespace link count (diagnostics); the - // classification itself needs only addresses + routes. - links := make(map[int32]string) - seq++ - if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpLinkRequest(seq), sa, func(mt uint16, body []byte) error { - if mt == uint16(unix.RTM_NEWLINK) { - li, perr := xtcpnl.ParseNewLink(body) - if perr != nil { - return perr + // Links: index -> name, used by the snapshot to resolve a route's egress Oif + // and a socket's kernel idiag_if to a human interface name. + var links map[uint32]string + if err := x.dumpRetrying(fd, sa, &seq, xtcpnl.BuildDumpLinkRequest, + func() { links = make(map[uint32]string) }, + func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWLINK) { + li, perr := xtcpnl.ParseNewLink(body) + if perr != nil { + return perr + } + links[uint32(li.Index)] = li.Name } - links[li.Index] = li.Name - } - return nil - }); err != nil { + return nil + }); err != nil { return nil, err } // Addresses (both families). var addrs []xtcpnl.AddrInfo - seq++ - if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpAddrRequest(unix.AF_UNSPEC, seq), sa, func(mt uint16, body []byte) error { - if mt == uint16(unix.RTM_NEWADDR) { - ai, perr := xtcpnl.ParseNewAddr(body) - if perr != nil { - return perr + if err := x.dumpRetrying(fd, sa, &seq, func(seq uint32) []byte { return xtcpnl.BuildDumpAddrRequest(unix.AF_UNSPEC, seq) }, + func() { addrs = addrs[:0] }, + func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWADDR) { + ai, perr := xtcpnl.ParseNewAddr(body) + if perr != nil { + return perr + } + addrs = append(addrs, ai) } - addrs = append(addrs, ai) - } - return nil - }); err != nil { + return nil + }); err != nil { return nil, err } // Routes (both families, all tables). var routes []xtcpnl.RouteInfo - seq++ - if err := xtcpnl.DumpRtnetlink(fd, xtcpnl.BuildDumpRouteRequest(unix.AF_UNSPEC, seq), sa, func(mt uint16, body []byte) error { - if mt == uint16(unix.RTM_NEWROUTE) { - ri, perr := xtcpnl.ParseNewRoute(body) - if perr != nil { - return perr + if err := x.dumpRetrying(fd, sa, &seq, func(seq uint32) []byte { return xtcpnl.BuildDumpRouteRequest(unix.AF_UNSPEC, seq) }, + func() { routes = routes[:0] }, + func(mt uint16, body []byte) error { + if mt == uint16(unix.RTM_NEWROUTE) { + ri, perr := xtcpnl.ParseNewRoute(body) + if perr != nil { + return perr + } + routes = append(routes, ri) } - routes = append(routes, ri) - } - return nil - }); err != nil { + return nil + }); err != nil { return nil, err } if x.debugLevel > 10 { log.Printf("dumpLocalityInNs: links:%d addrs:%d routes:%d", len(links), len(addrs), len(routes)) } - return localnet.BuildSnapshot(addrs, routes), nil + return localnet.BuildSnapshot(addrs, routes, links), nil +} + +// dumpRetrying runs one rtnetlink dump on fd, re-issuing it with a fresh +// sequence number when the kernel reports NLM_F_DUMP_INTR (the table changed +// while being dumped, so the reply may be inconsistent). reset clears the +// caller's accumulator before every attempt so a partial, interrupted stream is +// never merged with the retry. Any other error, or exhausting +// localityDumpRetriesCst, is returned to the caller. seq is advanced once per +// attempt; DumpRtnetlink filters replies by it, so a slow reply to an earlier +// attempt cannot pollute a later one. +func (x *XTCP) dumpRetrying(fd int, sa *unix.SockaddrNetlink, seq *uint32, + build func(seq uint32) []byte, reset func(), onMsg func(msgType uint16, body []byte) error) error { + for attempt := 0; ; attempt++ { + reset() + *seq++ + err := xtcpnl.DumpRtnetlink(fd, build(*seq), sa, onMsg) + if !errors.Is(err, xtcpnl.ErrDumpInterrupted) || attempt >= localityDumpRetriesCst { + return err + } + x.pC.WithLabelValues("dumpLocality", "interrupted", "retry").Inc() + } } diff --git a/pkg/xtcp/enrich_locality_test.go b/pkg/xtcp/enrich_locality_test.go new file mode 100644 index 0000000..c94e6e4 --- /dev/null +++ b/pkg/xtcp/enrich_locality_test.go @@ -0,0 +1,685 @@ +package xtcp + +import ( + "encoding/binary" + "errors" + "sort" + "syscall" + "testing" + "time" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promauto" + "github.com/prometheus/client_golang/prometheus/testutil" + "golang.org/x/sys/unix" + "google.golang.org/protobuf/types/known/durationpb" + + "github.com/randomizedcoder/xtcp2/gen/go/xtcp_config" + "github.com/randomizedcoder/xtcp2/pkg/localnet" + "github.com/randomizedcoder/xtcp2/pkg/xtcpnl" +) + +// ---- refreshLocality lifecycle ------------------------------------------------ +// +// refreshLocality is driven with an injected dumper and clock, so every rule — +// full vs partial pass, keep-last-good, negative cache + backoff, loopback-only +// re-dump, the per-pass cap, vanished-namespace cleanup — is asserted without +// setns or a kernel. + +// newLocalityFixture builds an XTCP with just enough state for refreshLocality: +// config, fresh metrics, and a recording dumper. +func newLocalityFixture(t *testing.T, interval time.Duration) *XTCP { + t.Helper() + x := new(XTCP) + x.config = &xtcp_config.XtcpConfig{ + EnrichLocalityEnable: true, + LocalityRefreshInterval: durationpb.New(interval), + } + reg := prometheus.NewRegistry() + x.pC = promauto.With(reg).NewCounterVec( + prometheus.CounterOpts{Subsystem: "xtcp_loctest", Name: promNameCounts, Help: promNameCounts}, + promLabels, + ) + x.pH = promauto.With(reg).NewSummaryVec( + prometheus.SummaryOpts{ + Subsystem: "xtcp_loctest", Name: promNameHistograms, Help: promNameHistograms, + Objectives: map[float64]float64{0.5: quantileError, 0.99: quantileError}, + MaxAge: summaryVecMaxAge, + }, + promLabels, + ) + x.pGV = promauto.With(reg).NewGaugeVec( + prometheus.GaugeOpts{Subsystem: "xtcp_loctest", Name: promNameGauges, Help: promNameGauges}, + promLabels, + ) + return x +} + +// Snapshot fixtures: a "real" namespace (non-loopback self address) and a +// freshly-created one that only has lo. +var ( + realSnap = localnet.BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 2, Local: []byte{10, 0, 0, 1}}}, nil, map[uint32]string{2: "eth0"}) + loSnap = localnet.BuildSnapshot([]xtcpnl.AddrInfo{{Family: unix.AF_INET, Index: 1, Local: []byte{127, 0, 0, 1}}}, nil, map[uint32]string{1: "lo"}) +) + +// snapKind names what a namespace's published snapshot should look like. +type snapKind int + +const ( + snapNone snapKind = iota // no snapshot published for the inode + snapReal // realSnap + snapLo // loSnap +) + +// dumpOutcome scripts the dumper's reply for one inode on one pass. +type dumpOutcome int + +const ( + dumpReal dumpOutcome = iota // success, non-loopback self + dumpLo // success, loopback only + dumpFail // hard failure (open/setns/dump error) +) + +// pass is one reconcile: the clock offset it runs at, the namespaces present, +// how the dumper answers, and what must be true afterwards. +type pass struct { + description string + at time.Duration // clock offset from t0 + nss []uint64 // namespace inodes present this reconcile + outcomes map[uint64]dumpOutcome // dumper reply per inode; missing = dumpReal + wantDumped []uint64 // exact set of inodes the dumper is asked for (nil = use wantDumpCount) + wantDumps int // number of dumper calls when the set is not deterministic (cap tests) + wantSnaps map[uint64]snapKind // expected published snapshot for the listed inodes + wantSnapLen int // expected len of the published map; checked when > 0 or when wantSnaps is all snapNone + wantRetry map[uint64]time.Duration +} + +func seq(from, to uint64) []uint64 { + out := make([]uint64, 0, to-from+1) + for i := from; i <= to; i++ { + out = append(out, i) + } + return out +} + +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestRefreshLocalityLifecycle +func TestRefreshLocalityLifecycle(t *testing.T) { + const refresh = 60 * time.Second + + tests := []struct { + description string + interval time.Duration + passes []pass + }{ + // positive + { + description: "first pass is full: every namespace dumped and published", + interval: refresh, + passes: []pass{ + {description: "p1", at: 0, nss: []uint64{1, 2}, wantDumped: []uint64{1, 2}, + wantSnaps: map[uint64]snapKind{1: snapReal, 2: snapReal}}, + }, + }, + { + description: "partial pass reuses existing snapshots and dumps only the new namespace", + interval: refresh, + passes: []pass{ + {description: "p1 full", at: 0, nss: []uint64{1, 2}, wantDumped: []uint64{1, 2}, + wantSnaps: map[uint64]snapKind{1: snapReal, 2: snapReal}}, + {description: "p2 +10s partial, ns 3 appears", at: 10 * time.Second, nss: []uint64{1, 2, 3}, wantDumped: []uint64{3}, + wantSnaps: map[uint64]snapKind{1: snapReal, 2: snapReal, 3: snapReal}}, + }, + }, + { + description: "full pass after the refresh interval re-dumps everything", + interval: refresh, + passes: []pass{ + {description: "p1 full", at: 0, nss: []uint64{1, 2}, wantDumped: []uint64{1, 2}}, + {description: "p2 +59s still partial", at: 59 * time.Second, nss: []uint64{1, 2}, wantDumped: []uint64{}}, + {description: "p3 +60s full", at: 60 * time.Second, nss: []uint64{1, 2}, wantDumped: []uint64{1, 2}}, + }, + }, + { + description: "namespace that disappears is dropped from the published map", + interval: refresh, + passes: []pass{ + {description: "p1", at: 0, nss: []uint64{1, 2}, wantDumped: []uint64{1, 2}}, + {description: "p2 ns 2 gone", at: 5 * time.Second, nss: []uint64{1}, wantDumped: []uint64{}, + wantSnaps: map[uint64]snapKind{1: snapReal}, wantSnapLen: 1}, + }, + }, + + // negative — hard failures and the negative cache + { + description: "failed dump keeps the last good snapshot and enters a 30s backoff", + interval: refresh, + passes: []pass{ + {description: "p1 ok", at: 0, nss: []uint64{1}, wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapReal}}, + {description: "p2 +60s full, dump fails -> keep, backoff 30s", at: 60 * time.Second, nss: []uint64{1}, + outcomes: map[uint64]dumpOutcome{1: dumpFail}, wantDumped: []uint64{1}, + wantSnaps: map[uint64]snapKind{1: snapReal}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p3 +70s inside backoff -> not dumped, still served", at: 70 * time.Second, nss: []uint64{1}, + wantDumped: []uint64{}, wantSnaps: map[uint64]snapKind{1: snapReal}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p4 +90s window open -> dumped ok, retry cleared", at: 90 * time.Second, nss: []uint64{1}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapReal}, wantRetry: map[uint64]time.Duration{}}, + }, + }, + { + description: "brand-new namespace whose first dump fails has no snapshot and is negative-cached", + interval: refresh, + passes: []pass{ + {description: "p1 fail", at: 0, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapNone}, wantSnapLen: 0, + wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + }, + }, + { + description: "repeated failures double the backoff 30s,60s,120s,240s and cap at 5m", + interval: refresh, + passes: []pass{ + {description: "fail#1 @0 -> 30s", at: 0, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "fail#2 @30s -> 60s", at: 30 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 60 * time.Second}}, + {description: "fail#3 @90s -> 120s", at: 90 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 120 * time.Second}}, + {description: "fail#4 @210s -> 240s", at: 210 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 240 * time.Second}}, + {description: "fail#5 @450s -> 300s cap", at: 450 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 5 * time.Minute}}, + {description: "fail#6 @750s -> stays 300s", at: 750 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantRetry: map[uint64]time.Duration{1: 5 * time.Minute}}, + }, + }, + { + description: "a namespace inside its backoff is skipped even by a full pass", + interval: 10 * time.Second, + passes: []pass{ + {description: "p1 fail -> 30s backoff", at: 0, nss: []uint64{1, 2}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1, 2}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p2 +10s full: ns 2 re-dumped, ns 1 skipped", at: 10 * time.Second, nss: []uint64{1, 2}, + wantDumped: []uint64{2}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p3 +30s full: ns 1 window open -> both dumped", at: 30 * time.Second, nss: []uint64{1, 2}, + wantDumped: []uint64{1, 2}, wantRetry: map[uint64]time.Duration{}}, + }, + }, + { + description: "retry state of a vanished namespace is dropped", + interval: refresh, + passes: []pass{ + {description: "p1 ns 2 fails", at: 0, nss: []uint64{1, 2}, outcomes: map[uint64]dumpOutcome{2: dumpFail}, + wantDumped: []uint64{1, 2}, wantRetry: map[uint64]time.Duration{2: 30 * time.Second}}, + {description: "p2 ns 2 gone", at: 5 * time.Second, nss: []uint64{1}, wantDumped: []uint64{}, + wantSnaps: map[uint64]snapKind{1: snapReal}, wantSnapLen: 1, wantRetry: map[uint64]time.Duration{}}, + }, + }, + + // corner — loopback-only namespaces + { + description: "loopback-only snapshot is published, re-dumped next pass, then backs off", + interval: refresh, + passes: []pass{ + {description: "p1 lo-only -> published, retry next pass", at: 0, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpLo}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapLo}, wantRetry: map[uint64]time.Duration{1: 0}}, + {description: "p2 +5s still lo -> re-dumped, now 30s backoff", at: 5 * time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpLo}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapLo}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p3 +10s inside backoff -> not dumped", at: 10 * time.Second, nss: []uint64{1}, + wantDumped: []uint64{}, wantSnaps: map[uint64]snapKind{1: snapLo}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p4 +40s veth plumbed -> real snapshot, retry cleared", at: 40 * time.Second, nss: []uint64{1}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapReal}, wantRetry: map[uint64]time.Duration{}}, + }, + }, + { + description: "loopback-only then hard failure: failure keeps the lo snapshot and moves to 30s", + interval: refresh, + passes: []pass{ + {description: "p1 lo", at: 0, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpLo}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapLo}, wantRetry: map[uint64]time.Duration{1: 0}}, + {description: "p2 fail", at: time.Second, nss: []uint64{1}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1}, wantSnaps: map[uint64]snapKind{1: snapLo}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + }, + }, + + // boundary — per-pass cap + { + description: "partial pass dumps at most 32 new namespaces, defers the rest to the next pass", + interval: refresh, + passes: []pass{ + {description: "p1 full, 1 ns", at: 0, nss: []uint64{1}, wantDumped: []uint64{1}}, + {description: "p2 +5s: 40 new -> 32 dumped, 8 deferred", at: 5 * time.Second, nss: seq(1, 41), wantDumps: 32, wantSnapLen: 33}, + {description: "p3 +10s: remaining 8 dumped", at: 10 * time.Second, nss: seq(1, 41), wantDumps: 8, wantSnapLen: 41}, + {description: "p4 +15s: nothing left", at: 15 * time.Second, nss: seq(1, 41), wantDumps: 0, wantSnapLen: 41}, + }, + }, + { + description: "exactly 32 new namespaces fit in one partial pass", + interval: refresh, + passes: []pass{ + {description: "p1", at: 0, nss: []uint64{1}, wantDumped: []uint64{1}}, + {description: "p2 32 new", at: 5 * time.Second, nss: seq(1, 33), wantDumps: 32, wantSnapLen: 33}, + }, + }, + { + description: "full pass is uncapped", + interval: refresh, + passes: []pass{ + {description: "p1 full with 100 namespaces", at: 0, nss: seq(1, 100), wantDumps: 100, wantSnapLen: 100}, + }, + }, + { + description: "expired retries count against the partial-pass cap too", + interval: refresh, + passes: []pass{ + {description: "p1 full: 40 ns all fail", at: 0, nss: seq(1, 40), outcomes: allFail(seq(1, 40)), wantDumps: 40, + wantSnaps: map[uint64]snapKind{1: snapNone, 40: snapNone}, wantSnapLen: 0}, + {description: "p2 +30s: windows open -> 32 retried, 8 deferred", at: 30 * time.Second, nss: seq(1, 40), wantDumps: 32, wantSnapLen: 32}, + }, + }, + + // corner — interval 0 + { + description: "interval 0: never another full pass, new namespaces and retries still handled", + interval: 0, + passes: []pass{ + {description: "p1 full (first ever), ns 1 fails", at: 0, nss: []uint64{1, 2}, outcomes: map[uint64]dumpOutcome{1: dumpFail}, + wantDumped: []uint64{1, 2}, wantRetry: map[uint64]time.Duration{1: 30 * time.Second}}, + {description: "p2 +1h: ns 1 retry open, ns 2 NOT refreshed, ns 3 new", at: time.Hour, nss: []uint64{1, 2, 3}, + wantDumped: []uint64{1, 3}, wantSnaps: map[uint64]snapKind{1: snapReal, 2: snapReal, 3: snapReal}, wantRetry: map[uint64]time.Duration{}}, + {description: "p3 +2h: nothing to do", at: 2 * time.Hour, nss: []uint64{1, 2, 3}, wantDumped: []uint64{}}, + }, + }, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + x := newLocalityFixture(t, tc.interval) + t0 := time.Date(2026, 9, 22, 12, 0, 0, 0, time.UTC) + now := t0 + x.localityClock = func() time.Time { return now } + + var asked []uint64 + var outcomes map[uint64]dumpOutcome + x.localityDumper = func(id nsIdentity) (*localnet.Snapshot, bool) { + asked = append(asked, id.inode) + switch outcomes[id.inode] { + case dumpFail: + return nil, false + case dumpLo: + return loSnap, true + default: + return realSnap, true + } + } + + for _, p := range tc.passes { + now = t0.Add(p.at) + asked = asked[:0] + outcomes = p.outcomes + + nss := make(map[uint64]nsIdentity, len(p.nss)) + for _, in := range p.nss { + nss[in] = nsIdentity{inode: in, pid: int(in) + 1000} + } + + // Retry entries untouched by this pass must keep their deadline. + prevRetry := make(map[uint64]localityRetryState, len(x.localityRetry)) + for k, v := range x.localityRetry { + prevRetry[k] = v + } + + x.refreshLocality(nss) + + // dumper calls + if p.wantDumped != nil { + got := append([]uint64(nil), asked...) + want := append([]uint64(nil), p.wantDumped...) + sort.Slice(got, func(i, j int) bool { return got[i] < got[j] }) + sort.Slice(want, func(i, j int) bool { return want[i] < want[j] }) + if !equalU64(got, want) { + t.Errorf("%s: dumped %v, want %v", p.description, got, want) + } + } else if len(asked) != p.wantDumps { + t.Errorf("%s: dumper called %d times, want %d", p.description, len(asked), p.wantDumps) + } + if len(uniqueU64(asked)) != len(asked) { + t.Errorf("%s: a namespace was dumped twice in one pass: %v", p.description, asked) + } + + // published map + pub := x.localityByInode.Load() + if pub == nil { + t.Fatalf("%s: no snapshot map published", p.description) + } + m := *pub + for inode, kind := range p.wantSnaps { + got := snapNone + switch m[inode] { + case realSnap: + got = snapReal + case loSnap: + got = snapLo + } + if got != kind { + t.Errorf("%s: snapshot[%d] = %v, want %v", p.description, inode, got, kind) + } + } + // Length is asserted when the pass states a positive count, or + // when every listed expectation is snapNone (an explicit "empty"). + if p.wantSnapLen > 0 || (len(p.wantSnaps) > 0 && allNone(p.wantSnaps)) { + if len(m) != p.wantSnapLen { + t.Errorf("%s: published %d snapshots, want %d", p.description, len(m), p.wantSnapLen) + } + } + for inode := range m { + if _, present := nss[inode]; !present { + t.Errorf("%s: published snapshot for vanished namespace %d", p.description, inode) + } + } + + // retry map + if p.wantRetry != nil { + if len(x.localityRetry) != len(p.wantRetry) { + t.Errorf("%s: retry map has %d entries %v, want %d %v", p.description, len(x.localityRetry), x.localityRetry, len(p.wantRetry), p.wantRetry) + } + for inode, backoff := range p.wantRetry { + st, ok := x.localityRetry[inode] + if !ok { + t.Errorf("%s: retry[%d] missing, want backoff %s", p.description, inode, backoff) + continue + } + wantNext := now.Add(backoff) // (re)set by a dump on this pass + if _, dumpedNow := uniqueU64(asked)[inode]; !dumpedNow { + wantNext = prevRetry[inode].nextRetry // skipped: deadline unchanged + } + if st.backoff != backoff || !st.nextRetry.Equal(wantNext) { + t.Errorf("%s: retry[%d] = {next:%s backoff:%s}, want {next:%s backoff:%s}", + p.description, inode, st.nextRetry.Format(time.TimeOnly), st.backoff, wantNext.Format(time.TimeOnly), backoff) + } + } + } + for inode := range x.localityRetry { + if _, present := nss[inode]; !present { + t.Errorf("%s: retry state kept for vanished namespace %d", p.description, inode) + } + } + + // gauges track the published map and the retry set + if g := testutil.ToFloat64(x.pGV.WithLabelValues("refreshLocality", "namespaces", "gauge")); int(g) != len(m) { + t.Errorf("%s: namespaces gauge = %v, want %d", p.description, g, len(m)) + } + if g := testutil.ToFloat64(x.pGV.WithLabelValues("refreshLocality", "retryBackoff", "gauge")); int(g) != len(x.localityRetry) { + t.Errorf("%s: retryBackoff gauge = %v, want %d", p.description, g, len(x.localityRetry)) + } + } + }) + } +} + +func allFail(inodes []uint64) map[uint64]dumpOutcome { + m := make(map[uint64]dumpOutcome, len(inodes)) + for _, in := range inodes { + m[in] = dumpFail + } + return m +} + +func allNone(m map[uint64]snapKind) bool { + for _, k := range m { + if k != snapNone { + return false + } + } + return true +} + +func equalU64(a, b []uint64) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i] != b[i] { + return false + } + } + return true +} + +func uniqueU64(a []uint64) map[uint64]struct{} { + m := make(map[uint64]struct{}, len(a)) + for _, v := range a { + m[v] = struct{}{} + } + return m +} + +// TestRefreshLocalityDeferredCounter checks the deferred / dumped counters and +// that a partial pass's duration is observed, on the cap scenario. +// +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestRefreshLocalityDeferredCounter +func TestRefreshLocalityDeferredCounter(t *testing.T) { + tests := []struct { + description string + firstNs []uint64 // namespaces on the (full) first pass + secondNs []uint64 // namespaces on the partial second pass + wantDumped float64 // total dumper calls over both passes + wantDeferred float64 // deferred on the second pass + }{ + {"40 new on a partial pass -> 32 dumped, 8 deferred", []uint64{1}, seq(1, 41), 1 + 32, 8}, + {"32 new fit exactly -> nothing deferred", []uint64{1}, seq(1, 33), 1 + 32, 0}, + {"no new namespaces -> nothing dumped or deferred", []uint64{1, 2}, []uint64{1, 2}, 2, 0}, + {"33 new -> exactly one deferred", []uint64{1}, seq(1, 34), 1 + 32, 1}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + x := newLocalityFixture(t, time.Minute) + now := time.Date(2026, 9, 22, 12, 0, 0, 0, time.UTC) + x.localityClock = func() time.Time { return now } + x.localityDumper = func(nsIdentity) (*localnet.Snapshot, bool) { return realSnap, true } + + mk := func(in []uint64) map[uint64]nsIdentity { + m := make(map[uint64]nsIdentity, len(in)) + for _, i := range in { + m[i] = nsIdentity{inode: i} + } + return m + } + x.refreshLocality(mk(tc.firstNs)) + now = now.Add(5 * time.Second) + x.refreshLocality(mk(tc.secondNs)) + + if got := testutil.ToFloat64(x.pC.WithLabelValues("refreshLocality", "dumped", "count")); got != tc.wantDumped { + t.Errorf("dumped counter = %v, want %v", got, tc.wantDumped) + } + if got := testutil.ToFloat64(x.pC.WithLabelValues("refreshLocality", "deferred", "count")); got != tc.wantDeferred { + t.Errorf("deferred counter = %v, want %v", got, tc.wantDeferred) + } + if got := testutil.ToFloat64(x.pC.WithLabelValues("refreshLocality", "full", "count")); got != 1 { + t.Errorf("full-pass counter = %v, want 1", got) + } + if got := testutil.ToFloat64(x.pC.WithLabelValues("refreshLocality", "partial", "count")); got != 1 { + t.Errorf("partial-pass counter = %v, want 1", got) + } + }) + } +} + +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestNextLocalityRetry +func TestNextLocalityRetry(t *testing.T) { + now := time.Date(2026, 9, 22, 12, 0, 0, 0, time.UTC) + tests := []struct { + description string + prev localityRetryState + retrying bool + hard bool + wantBackoff time.Duration + }{ + // positive + {"no history, hard failure -> 30s", localityRetryState{}, false, true, 30 * time.Second}, + {"no history, loopback-only -> 0 (next pass)", localityRetryState{}, false, false, 0}, + // boundary + {"after a next-pass retry, loopback again -> 30s", localityRetryState{backoff: 0}, true, false, 30 * time.Second}, + {"after a next-pass retry, hard failure -> 30s", localityRetryState{backoff: 0}, true, true, 30 * time.Second}, + {"30s -> 60s", localityRetryState{backoff: 30 * time.Second}, true, true, 60 * time.Second}, + {"120s -> 240s", localityRetryState{backoff: 120 * time.Second}, true, false, 240 * time.Second}, + {"240s -> capped 300s", localityRetryState{backoff: 240 * time.Second}, true, true, 5 * time.Minute}, + {"300s stays 300s", localityRetryState{backoff: 5 * time.Minute}, true, true, 5 * time.Minute}, + // corner — a stale entry with a backoff above the cap is pulled back to it + {"above-cap backoff is clamped", localityRetryState{backoff: time.Hour}, true, true, 5 * time.Minute}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + got := nextLocalityRetry(tc.prev, tc.retrying, now, tc.hard) + if got.backoff != tc.wantBackoff { + t.Errorf("backoff = %s, want %s", got.backoff, tc.wantBackoff) + } + if !got.nextRetry.Equal(now.Add(tc.wantBackoff)) { + t.Errorf("nextRetry = %s, want %s", got.nextRetry, now.Add(tc.wantBackoff)) + } + }) + } +} + +// ---- dumpRetrying over a socketpair ------------------------------------------- + +// nlmsgT lays out one netlink message for the fake kernel. +func nlmsgT(typ, flags uint16, seq uint32, body []byte) []byte { + b := make([]byte, xtcpnl.NlMsgHdrSizeCst+len(body)) + binary.LittleEndian.PutUint32(b[0:4], uint32(len(b))) + binary.LittleEndian.PutUint16(b[4:6], typ) + binary.LittleEndian.PutUint16(b[6:8], flags) + binary.LittleEndian.PutUint32(b[8:12], seq) + copy(b[xtcpnl.NlMsgHdrSizeCst:], body) + return b +} + +// reply kinds the fake kernel can produce for one dump attempt. +type attemptReply int + +const ( + replyClean attemptReply = iota // one RTM_NEWLINK + DONE + replyInterrupted // one RTM_NEWLINK flagged DUMP_INTR + DONE + replyENOENT // NLMSG_ERROR -ENOENT +) + +// go test -ldflags=-checklinkname=0 ./pkg/xtcp/ -run TestDumpRetrying +func TestDumpRetrying(t *testing.T) { + tests := []struct { + description string + replies []attemptReply // per attempt, in order + wantAttempts int // reset() calls == requests received + wantErr error // errors.Is target, nil for success + wantMsgs int // messages delivered to onMsg on the FINAL attempt + }{ + // positive + {"clean first attempt -> 1 attempt, 1 message", []attemptReply{replyClean}, 1, nil, 1}, + {"interrupted once, then clean -> 2 attempts, only the clean one delivered", []attemptReply{replyInterrupted, replyClean}, 2, nil, 1}, + {"interrupted three times, fourth clean -> 4 attempts, success", []attemptReply{replyInterrupted, replyInterrupted, replyInterrupted, replyClean}, 4, nil, 1}, + // negative / boundary + {"interrupted four times -> retries exhausted, ErrDumpInterrupted", []attemptReply{replyInterrupted, replyInterrupted, replyInterrupted, replyInterrupted}, 4, xtcpnl.ErrDumpInterrupted, 0}, + {"hard error is not retried", []attemptReply{replyENOENT}, 1, syscall.ENOENT, 0}, + {"interrupted then hard error -> stops at the error", []attemptReply{replyInterrupted, replyENOENT}, 2, syscall.ENOENT, 0}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + x := newLocalityFixture(t, time.Minute) + + fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_SEQPACKET|unix.SOCK_CLOEXEC, 0) + if err != nil { + t.Fatalf("Socketpair: %v", err) + } + t.Cleanup(func() { _ = unix.Close(fds[0]); _ = unix.Close(fds[1]) }) + tv := unix.Timeval{Sec: 2} + if err := unix.SetsockoptTimeval(fds[0], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv); err != nil { + t.Fatalf("SO_RCVTIMEO: %v", err) + } + + // Fake kernel: for each scripted attempt, read the request, echo its + // seq into the reply so the seq filter accepts it. + seqs := make(chan uint32, len(tc.replies)) + kernelDone := make(chan struct{}) + go func() { + defer close(kernelDone) + rb := make([]byte, 256) + for _, r := range tc.replies { + n, _, rerr := unix.Recvfrom(fds[1], rb, 0) + if rerr != nil || n < xtcpnl.NlMsgHdrSizeCst { + return + } + s := binary.LittleEndian.Uint32(rb[8:12]) + seqs <- s + var out []byte + switch r { + case replyClean: + out = append(out, nlmsgT(uint16(unix.RTM_NEWLINK), unix.NLM_F_MULTI, s, make([]byte, xtcpnl.IfInfomsgSizeCst))...) + out = append(out, nlmsgT(uint16(unix.NLMSG_DONE), unix.NLM_F_MULTI, s, make([]byte, 4))...) + case replyInterrupted: + out = append(out, nlmsgT(uint16(unix.RTM_NEWLINK), unix.NLM_F_MULTI|unix.NLM_F_DUMP_INTR, s, make([]byte, xtcpnl.IfInfomsgSizeCst))...) + out = append(out, nlmsgT(uint16(unix.NLMSG_DONE), unix.NLM_F_MULTI, s, make([]byte, 4))...) + case replyENOENT: + body := make([]byte, 4+xtcpnl.NlMsgHdrSizeCst) + errno := int32(syscall.ENOENT) + binary.LittleEndian.PutUint32(body[0:4], uint32(-errno)) + out = nlmsgT(uint16(unix.NLMSG_ERROR), 0, s, body) + } + if _, werr := unix.Write(fds[1], out); werr != nil { + return + } + } + }() + + var seq uint32 + resets, msgs := 0, 0 + err = x.dumpRetrying(fds[0], nil, &seq, xtcpnl.BuildDumpLinkRequest, + func() { resets++; msgs = 0 }, + func(mt uint16, _ []byte) error { + if mt == uint16(unix.RTM_NEWLINK) { + msgs++ + } + return nil + }) + + if tc.wantErr == nil && err != nil { + t.Errorf("err = %v, want nil", err) + } + if tc.wantErr != nil && !errors.Is(err, tc.wantErr) { + t.Errorf("err = %v, want errors.Is(%v)", err, tc.wantErr) + } + if resets != tc.wantAttempts { + t.Errorf("reset called %d times, want %d", resets, tc.wantAttempts) + } + if int(seq) != tc.wantAttempts { + t.Errorf("seq advanced to %d, want %d (one per attempt)", seq, tc.wantAttempts) + } + if msgs != tc.wantMsgs { + t.Errorf("final attempt delivered %d messages, want %d", msgs, tc.wantMsgs) + } + // Every request carried a distinct, increasing seq. Wait for the fake + // kernel to finish so closing seqs is ordered after its last send. + select { + case <-kernelDone: + case <-time.After(2 * time.Second): + t.Fatal("fake kernel did not finish") + } + close(seqs) + var prev uint32 + n := 0 + for s := range seqs { + n++ + if s <= prev { + t.Errorf("request seq %d not greater than previous %d", s, prev) + } + prev = s + } + if n != tc.wantAttempts { + t.Errorf("fake kernel saw %d requests, want %d", n, tc.wantAttempts) + } + if tc.wantErr == nil || errors.Is(err, xtcpnl.ErrDumpInterrupted) { + retries := testutil.ToFloat64(x.pC.WithLabelValues("dumpLocality", "interrupted", "retry")) + if wantRetries := float64(tc.wantAttempts - 1); retries != wantRetries { + t.Errorf("interrupted-retry counter = %v, want %v", retries, wantRetries) + } + } + }) + } +} diff --git a/pkg/xtcp/prometheus.go b/pkg/xtcp/prometheus.go index 8edac95..b885013 100644 --- a/pkg/xtcp/prometheus.go +++ b/pkg/xtcp/prometheus.go @@ -17,10 +17,12 @@ const ( promNameCounts = "counts" promNameHistograms = "histograms" promNameGauge = "gauge" + promNameGauges = "gauges" promHelpCounts = "xtcp counts" promHelpHistograms = "xtcp historgrams" //nolint:misspell // preserved spelling from existing metric — renaming would invalidate downstream dashboards promHelpGauge = "xtcp network namespace gauge" + promHelpGauges = "xtcp gauges" promLabelFunction = "function" promLabelVariable = "variable" @@ -79,4 +81,13 @@ func (x *XTCP) InitPromethus(wg *sync.WaitGroup) { }, ) + x.pGV = factory.NewGaugeVec( + prometheus.GaugeOpts{ + Subsystem: promSubsystemXTCP, + Name: promNameGauges, + Help: promHelpGauges, + }, + promLabels, + ) + } diff --git a/pkg/xtcp/schema_version.go b/pkg/xtcp/schema_version.go index bf1787a..6deb13a 100644 --- a/pkg/xtcp/schema_version.go +++ b/pkg/xtcp/schema_version.go @@ -8,5 +8,16 @@ package xtcp // proto3 decodes it to the zero value and ClickHouse routes those rows to the // "legacy" (_v0) table. Bump this constant (and add the matching _vN table + MV // in build/containers/clickhouse/initdb.d) whenever the record format changes -// meaningfully. -const XtcpFlatRecordSchemaVersion = 1 +// meaningfully — i.e. any field RENAME or RENUMBER. Adding a field in a free +// slot is not a bump (name-mapped consumers just see a new column). +// +// History: +// +// 0 pre-versioning (no schema_version on the wire) +// 1 2026-08/09: metadata blocks 1-299, enrichment 300s, payload 1000+ +// 2 2026-09: payload names aligned to kernel struct spelling (tcp_info_rttvar, +// inet_diag_tos, inet_diag_cgroup_id, ...), enrichment 300s regrouped by +// subject (egress 301/302 -> 311/312, next_hop_asn renamed dest_next_hop_asn), +// c_group 2103 -> inet_diag_cgroup_id 2003. See +// build/containers/clickhouse/sql/migrations/v2.sql. +const XtcpFlatRecordSchemaVersion = 2 diff --git a/pkg/xtcp/xtcp.go b/pkg/xtcp/xtcp.go index 895a110..9d8260a 100644 --- a/pkg/xtcp/xtcp.go +++ b/pkg/xtcp/xtcp.go @@ -133,6 +133,15 @@ type XTCP struct { // and is touched only under reconcileMu (the reconcile owner). localityByInode atomic.Pointer[map[uint64]*localnet.Snapshot] lastLocalityRefresh time.Time + // localityRetry is the per-namespace negative cache for locality dumps: a + // namespace whose dump failed, or came back loopback-only (veth not plumbed + // yet), is retried on a 30s→5m backoff instead of every reconcile. Owned by + // the reconcile path (reconcileMu). See refreshLocality. + localityRetry map[uint64]localityRetryState + // localityDumper / localityClock are test seams for refreshLocality: nil + // means nsLocalitySnapshot (setns + rtnetlink dumps) and time.Now. + localityDumper func(nsIdentity) (*localnet.Snapshot, bool) + localityClock func() time.Time RTATypeDeserializer map[int]func(buf []byte, xtcpRecord *xtcp_flat_record.XtcpFlatRecord) (err error) RTATypeDeserializerStr map[int]string @@ -199,6 +208,10 @@ type XTCP struct { pC *prometheus.CounterVec pH *prometheus.SummaryVec pG prometheus.Gauge + // pGV is the labelled gauge family for point-in-time sizes that are not + // the namespace-map count pG already carries (e.g. how many namespaces + // hold a locality snapshot / sit in the retry backoff). + pGV *prometheus.GaugeVec debugLevel uint32 } diff --git a/pkg/xtcpnl/xtcp_writer_test.go b/pkg/xtcpnl/xtcp_writer_test.go index b1984b0..468b949 100644 --- a/pkg/xtcpnl/xtcp_writer_test.go +++ b/pkg/xtcpnl/xtcp_writer_test.go @@ -103,7 +103,7 @@ func TestDeserializeXXXXTCP(t *testing.T) { min: TypeOfServiceSizeCst, parse: DeserializeTypeOfServiceXTCP, verify: func(t *testing.T, x *xtcp_flat_record.XtcpFlatRecord) { - if x.TypeOfService == 0 { + if x.InetDiagTos == 0 { t.Errorf("TypeOfService unset") } }, @@ -113,7 +113,7 @@ func TestDeserializeXXXXTCP(t *testing.T) { min: TrafficClassSizeCst, parse: DeserializeTrafficClassXTCP, verify: func(t *testing.T, x *xtcp_flat_record.XtcpFlatRecord) { - if x.TrafficClass == 0 { + if x.InetDiagTclass == 0 { t.Errorf("TrafficClass unset") } }, @@ -123,7 +123,7 @@ func TestDeserializeXXXXTCP(t *testing.T) { min: ShutdownSizeCst, parse: DeserializeShutdownXTCP, verify: func(t *testing.T, x *xtcp_flat_record.XtcpFlatRecord) { - if x.ShutdownState == 0 { + if x.InetDiagShutdown == 0 { t.Errorf("ShutdownState unset") } }, @@ -146,7 +146,7 @@ func TestDeserializeXXXXTCP(t *testing.T) { min: ClassIDSizeCst, parse: DeserializeClassIDXTCP, verify: func(t *testing.T, x *xtcp_flat_record.XtcpFlatRecord) { - if x.ClassId == 0 { + if x.InetDiagClassId == 0 { t.Errorf("ClassId unset") } }, @@ -156,7 +156,7 @@ func TestDeserializeXXXXTCP(t *testing.T) { min: CGroupIDSizeCst, parse: DeserializeCGroupIDXTCP, verify: func(t *testing.T, x *xtcp_flat_record.XtcpFlatRecord) { - if x.CGroup == 0 { + if x.InetDiagCgroupId == 0 { t.Errorf("CGroup unset") } }, diff --git a/pkg/xtcpnl/xtcpnl_extra_test.go b/pkg/xtcpnl/xtcpnl_extra_test.go index e05c181..611a1df 100644 --- a/pkg/xtcpnl/xtcpnl_extra_test.go +++ b/pkg/xtcpnl/xtcpnl_extra_test.go @@ -204,8 +204,8 @@ func TestDeserializeCongInfoXTCP_dispatch(t *testing.T) { if err := DeserializeCongInfoXTCP(tc.data, x); err != nil { t.Fatalf("err = %v", err) } - if x.CongestionAlgorithmEnum != tc.wantAlg { - t.Errorf("alg = %v, want %v", x.CongestionAlgorithmEnum, tc.wantAlg) + if x.InetDiagCongEnum != tc.wantAlg { + t.Errorf("alg = %v, want %v", x.InetDiagCongEnum, tc.wantAlg) } }) } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_cgroupid.go b/pkg/xtcpnl/xtcpnl_inet_diag_cgroupid.go index f661d11..a681c72 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_cgroupid.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_cgroupid.go @@ -100,7 +100,7 @@ func DeserializeCGroupIDXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (e return ErrCGroupIDSmall } - x.CGroup = binary.LittleEndian.Uint64(data[0:8]) + x.InetDiagCgroupId = binary.LittleEndian.Uint64(data[0:8]) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_classid.go b/pkg/xtcpnl/xtcpnl_inet_diag_classid.go index 3c05476..c8ece1d 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_classid.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_classid.go @@ -85,7 +85,7 @@ func DeserializeClassIDXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (er return ErrClassIDSmall } - x.ClassId = binary.LittleEndian.Uint32(data[0:4]) + x.InetDiagClassId = binary.LittleEndian.Uint32(data[0:4]) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_conginfo.go b/pkg/xtcpnl/xtcpnl_inet_diag_conginfo.go index 0198371..44aa37e 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_conginfo.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_conginfo.go @@ -94,7 +94,7 @@ func DeserializeCongInfoXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (e // against 3-char strings would never match, so we use the 3-char prefix. switch string(data[0:3]) { case "cub": - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_CUBIC case "bbr": // Distinguish bbr1 / bbr2 / bbr3 via the 4th byte. The XtcpFlatRecord // proto defines BBR1/BBR2/BBR3 as separate enum values — previously @@ -104,16 +104,16 @@ func DeserializeCongInfoXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (e // the buffer is long enough. switch { case len(data) >= 4 && data[3] == '3': - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR3 + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR3 case len(data) >= 4 && data[3] == '2': - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR2 + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR2 default: - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR1 + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_BBR1 } case "dct": - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_DCTCP + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_DCTCP case "veg": - x.CongestionAlgorithmEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_VEGAS + x.InetDiagCongEnum = xtcp_flat_record.XtcpFlatRecord_CONGESTION_ALGORITHM_VEGAS } return nil diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_shutdown.go b/pkg/xtcpnl/xtcpnl_inet_diag_shutdown.go index a46e122..a9ba445 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_shutdown.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_shutdown.go @@ -84,7 +84,7 @@ func DeserializeShutdownXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (e return ErrShutdownSmall } - x.ShutdownState = uint32(data[0]) + x.InetDiagShutdown = uint32(data[0]) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_skmeminfo.go b/pkg/xtcpnl/xtcpnl_inet_diag_skmeminfo.go index c6bfd2f..bee486a 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_skmeminfo.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_skmeminfo.go @@ -120,9 +120,9 @@ func DeserializeSkMemInfoXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) ( } x.SkMemInfoRmemAlloc = binary.LittleEndian.Uint32(data[0:4]) - x.SkMemInfoRcvBuf = binary.LittleEndian.Uint32(data[4:8]) + x.SkMemInfoRcvbuf = binary.LittleEndian.Uint32(data[4:8]) x.SkMemInfoWmemAlloc = binary.LittleEndian.Uint32(data[8:12]) - x.SkMemInfoSndBuf = binary.LittleEndian.Uint32(data[12:16]) + x.SkMemInfoSndbuf = binary.LittleEndian.Uint32(data[12:16]) x.SkMemInfoFwdAlloc = binary.LittleEndian.Uint32(data[16:20]) x.SkMemInfoWmemQueued = binary.LittleEndian.Uint32(data[20:24]) x.SkMemInfoOptmem = binary.LittleEndian.Uint32(data[24:28]) diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_sockopt.go b/pkg/xtcpnl/xtcpnl_inet_diag_sockopt.go index d6b041b..298616f 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_sockopt.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_sockopt.go @@ -95,7 +95,7 @@ func DeserializeSockOptReflection(data []byte, c *SockOpt) (n int, err error) { } // DeserializeSockOptXTCP reads an INET_DIAG_SOCKOPT (22) attribute into -// XtcpFlatRecord.SockOpt. Previously typed against the wrong target +// XtcpFlatRecord.InetDiagSockopt. Previously typed against the wrong target // (*Envelope_XtcpFlatRecord), which didn't match the runtime dispatch // map signature in pkg/xtcp/deserializers.go — the dispatch entry had // to be filled with DeserializeCGroupIDXTCP as a placeholder, so the @@ -107,7 +107,7 @@ func DeserializeSockOptXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) (er return ErrSockOptSmall } - x.SockOpt = uint32(binary.LittleEndian.Uint16(data[0:2])) + x.InetDiagSockopt = uint32(binary.LittleEndian.Uint16(data[0:2])) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_tcclass_info.go b/pkg/xtcpnl/xtcpnl_inet_diag_tcclass_info.go index 0b120f2..7c8a8d8 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_tcclass_info.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_tcclass_info.go @@ -85,7 +85,7 @@ func DeserializeTrafficClassXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord return ErrTrafficClassSmall } - x.TrafficClass = uint32(data[0]) + x.InetDiagTclass = uint32(data[0]) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_tcpinfo.go b/pkg/xtcpnl/xtcpnl_inet_diag_tcpinfo.go index 05c24d1..f7e5612 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_tcpinfo.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_tcpinfo.go @@ -920,10 +920,10 @@ func deserializeTCPInfoXTCPBase(data []byte, x *xtcp_flat_record.XtcpFlatRecord) x.TcpInfoProbes = uint32(data[3]) x.TcpInfoBackoff = uint32(data[4]) x.TcpInfoOptions = uint32(data[5]) - x.TcpInfoSendScale = uint32(data[6] & 0x0F) - x.TcpInfoRcvScale = uint32((data[6] >> 4) & 0x0F) + x.TcpInfoSndWscale = uint32(data[6] & 0x0F) + x.TcpInfoRcvWscale = uint32((data[6] >> 4) & 0x0F) x.TcpInfoDeliveryRateAppLimited = uint32(data[7] & 0x01) - x.TcpInfoFastOpenClientFailed = uint32((data[7] >> 1) & 0x03) + x.TcpInfoFastopenClientFail = uint32((data[7] >> 1) & 0x03) x.TcpInfoRto = binary.LittleEndian.Uint32(data[8:12]) x.TcpInfoAto = binary.LittleEndian.Uint32(data[12:16]) @@ -945,10 +945,10 @@ func deserializeTCPInfoXTCPBase(data []byte, x *xtcp_flat_record.XtcpFlatRecord) x.TcpInfoPmtu = binary.LittleEndian.Uint32(data[60:64]) x.TcpInfoRcvSsthresh = binary.LittleEndian.Uint32(data[64:68]) x.TcpInfoRtt = binary.LittleEndian.Uint32(data[68:72]) - x.TcpInfoRttVar = binary.LittleEndian.Uint32(data[72:76]) + x.TcpInfoRttvar = binary.LittleEndian.Uint32(data[72:76]) x.TcpInfoSndSsthresh = binary.LittleEndian.Uint32(data[76:80]) x.TcpInfoSndCwnd = binary.LittleEndian.Uint32(data[80:84]) - x.TcpInfoAdvMss = binary.LittleEndian.Uint32(data[84:88]) + x.TcpInfoAdvmss = binary.LittleEndian.Uint32(data[84:88]) x.TcpInfoReordering = binary.LittleEndian.Uint32(data[88:92]) x.TcpInfoRcvRtt = binary.LittleEndian.Uint32(data[92:96]) @@ -964,7 +964,7 @@ func deserializeTCPInfoXTCPBase(data []byte, x *xtcp_flat_record.XtcpFlatRecord) x.TcpInfoSegsOut = binary.LittleEndian.Uint32(data[136:140]) x.TcpInfoSegsIn = binary.LittleEndian.Uint32(data[140:144]) - x.TcpInfoNotSentBytes = binary.LittleEndian.Uint32(data[144:148]) + x.TcpInfoNotsentBytes = binary.LittleEndian.Uint32(data[144:148]) x.TcpInfoMinRtt = binary.LittleEndian.Uint32(data[148:152]) x.TcpInfoDataSegsIn = binary.LittleEndian.Uint32(data[152:156]) x.TcpInfoDataSegsOut = binary.LittleEndian.Uint32(data[156:160]) diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_tosinfo.go b/pkg/xtcpnl/xtcpnl_inet_diag_tosinfo.go index e252598..01b58f0 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_tosinfo.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_tosinfo.go @@ -85,7 +85,7 @@ func DeserializeTypeOfServiceXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecor return ErrTypeOfServiceSmall } - x.TypeOfService = uint32(data[0]) + x.InetDiagTos = uint32(data[0]) return nil } diff --git a/pkg/xtcpnl/xtcpnl_inet_diag_vegasinfo.go b/pkg/xtcpnl/xtcpnl_inet_diag_vegasinfo.go index b6503f2..ce3dc81 100644 --- a/pkg/xtcpnl/xtcpnl_inet_diag_vegasinfo.go +++ b/pkg/xtcpnl/xtcpnl_inet_diag_vegasinfo.go @@ -101,9 +101,9 @@ func DeserializeVegasInfoXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) ( } x.VegasInfoEnabled = binary.LittleEndian.Uint32(data[0:4]) - x.VegasInfoRttCnt = binary.LittleEndian.Uint32(data[4:8]) + x.VegasInfoRttcnt = binary.LittleEndian.Uint32(data[4:8]) x.VegasInfoRtt = binary.LittleEndian.Uint32(data[8:12]) - x.VegasInfoMinRtt = binary.LittleEndian.Uint32(data[12:16]) + x.VegasInfoMinrtt = binary.LittleEndian.Uint32(data[12:16]) return nil } @@ -111,7 +111,7 @@ func DeserializeVegasInfoXTCP(data []byte, x *xtcp_flat_record.XtcpFlatRecord) ( func ZeroizeVegasInfoXTCP(x *xtcp_flat_record.XtcpFlatRecord) { // func ZeroizeVegasInfoXTCP(x *xtcp_flat_record.Envelope_XtcpFlatRecord) { x.VegasInfoEnabled = 0 - x.VegasInfoRttCnt = 0 + x.VegasInfoRttcnt = 0 x.VegasInfoRtt = 0 - x.VegasInfoMinRtt = 0 + x.VegasInfoMinrtt = 0 } diff --git a/pkg/xtcpnl/xtcpnl_rtmsg.go b/pkg/xtcpnl/xtcpnl_rtmsg.go index a020e70..620a9f8 100644 --- a/pkg/xtcpnl/xtcpnl_rtmsg.go +++ b/pkg/xtcpnl/xtcpnl_rtmsg.go @@ -39,6 +39,11 @@ type RtMsg struct { const ( RtMsgSizeCst = 12 RtMsgReadCst = RtMsgSizeCst + + // RtaNhID is RTA_NH_ID from include/uapi/linux/rtnetlink.h (Linux 5.3+): + // the id of the nexthop object a route points at instead of carrying its + // own RTA_GATEWAY / RTA_OIF. golang.org/x/sys/unix does not export it. + RtaNhID uint16 = 30 ) var ( @@ -78,23 +83,31 @@ func DeserializeRtMsgReflection(data []byte, m *RtMsg) (n int, err error) { // RouteInfo is the subset of an RTM_NEWROUTE message xtcp2 keeps. DstLen and the // header table/scope/type come from the rtmsg header; Dst/Gateway/PrefSrc hold // raw network-order address bytes. Table is upgraded from RTA_TABLE when present -// (full table ids exceed the 8-bit header field). The connected-subnet test is -// Type==RTN_UNICAST && Gateway==nil && has a Dst prefix (NOT scope-gated: IPv4 -// connected subnets are scope-link but IPv6 connected subnets are +// (full table ids exceed the 8-bit header field). The local-subnet test +// (pkg/localnet) is Type==RTN_UNICAST && has a Dst prefix && no next hop, where +// "next hop" is any of Gateway, HasVia, HasMultipath or NhID (NOT scope-gated: +// IPv4 connected subnets are scope-link but IPv6 connected subnets are // scope-universe); a locally-attached address is Type==RTN_LOCAL (typically in // RT_TABLE_LOCAL, scope host). +// +// HasMultipath / HasVia / NhID only record that the route is reached via a next +// hop expressed outside RTA_GATEWAY; the nexthop contents themselves (per-path +// gateways and interfaces) are not parsed. type RouteInfo struct { - Family uint8 - DstLen uint8 - Table uint32 // header rtm_table, upgraded by RTA_TABLE - Scope uint8 - Type uint8 - Protocol uint8 - Dst []byte // RTA_DST - Gateway []byte // RTA_GATEWAY - PrefSrc []byte // RTA_PREFSRC - Oif uint32 // RTA_OIF - Priority uint32 // RTA_PRIORITY + Family uint8 + DstLen uint8 + Table uint32 // header rtm_table, upgraded by RTA_TABLE + Scope uint8 + Type uint8 + Protocol uint8 + Dst []byte // RTA_DST + Gateway []byte // RTA_GATEWAY + PrefSrc []byte // RTA_PREFSRC + Oif uint32 // RTA_OIF + Priority uint32 // RTA_PRIORITY + HasMultipath bool // RTA_MULTIPATH present (ECMP nexthop list; gateways live inside it) + HasVia bool // RTA_VIA present (gateway of a different address family) + NhID uint32 // RTA_NH_ID (nexthop object id; 0 = none) } // ParseNewRoute decodes an RTM_NEWROUTE message body (the bytes after the @@ -133,6 +146,14 @@ func ParseNewRoute(body []byte) (RouteInfo, error) { if len(val) >= 4 { ri.Table = binary.LittleEndian.Uint32(val[0:4]) } + case uint16(unix.RTA_MULTIPATH): + ri.HasMultipath = true + case uint16(unix.RTA_VIA): + ri.HasVia = true + case RtaNhID: + if len(val) >= 4 { + ri.NhID = binary.LittleEndian.Uint32(val[0:4]) + } } }) if err != nil { diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink.go b/pkg/xtcpnl/xtcpnl_rtnetlink.go index 61b7d83..e100e99 100644 --- a/pkg/xtcpnl/xtcpnl_rtnetlink.go +++ b/pkg/xtcpnl/xtcpnl_rtnetlink.go @@ -40,6 +40,15 @@ var ( ErrBadMsgLen = errors.New("xtcpnl: rtnetlink message length out of range") // ErrNetlinkError indicates a malformed NLMSG_ERROR (too short for errno). ErrNetlinkError = errors.New("xtcpnl: rtnetlink error message truncated") + // ErrDumpInterrupted indicates the kernel flagged a reply with + // NLM_F_DUMP_INTR: the table changed while it was being dumped, so the + // stream may be inconsistent (entries missing or duplicated). DumpRtnetlink + // still drains the stream to NLMSG_DONE before returning this, so the socket + // is immediately reusable; callers should discard what onMsg collected and + // re-issue the request. + ErrDumpInterrupted = errors.New("xtcpnl: rtnetlink dump interrupted (NLM_F_DUMP_INTR), retry") + // ErrShortRequest indicates a request shorter than a bare nlmsghdr. + ErrShortRequest = errors.New("xtcpnl: rtnetlink request shorter than nlmsghdr") ) // buildDumpRequest lays out a DUMP request: a 16-byte nlmsghdr @@ -87,58 +96,155 @@ func BuildDumpRouteRequest(family uint8, seq uint32) []byte { } // DumpRtnetlink sends request on fd and drives the multipart reply, invoking -// onMsg for every RTM_NEW* message body (the bytes after the 16-byte nlmsghdr). -// It returns nil at NLMSG_DONE (or a zero-errno ACK), a wrapped syscall.Errno -// for a non-zero NLMSG_ERROR, and skips NLMSG_NOOP. The socket should have a -// receive timeout set so a missing DONE degrades to an error instead of -// blocking. onMsg must copy any bytes it needs to retain — the receive buffer -// is reused across recvs. +// onMsg for every RTM_NEW* message body (the bytes after the 16-byte nlmsghdr) +// whose nlmsg_seq matches the request's. It returns nil at NLMSG_DONE (or a +// zero-errno ACK), a wrapped syscall.Errno for a non-zero NLMSG_ERROR, and +// skips NLMSG_NOOP. The socket should have a receive timeout set so a missing +// DONE degrades to an error instead of blocking. onMsg must copy any bytes it +// needs to retain — the receive buffer is reused across recvs. +// +// Hardening (see walkNlMsgs for the per-datagram rules): +// - datagrams whose sender pid is not the kernel (nlmsg from another +// userspace process on a multicast-joined socket) are ignored; +// - messages whose nlmsg_seq differs from the request's are ignored, so a +// stale reply (or a stale NLMSG_DONE) left over from an earlier timed-out +// dump on the same socket cannot be mistaken for this one; +// - a reply flagged NLM_F_DUMP_INTR makes the whole dump return +// ErrDumpInterrupted — but only after the stream has been drained to +// NLMSG_DONE, so the caller can retry on the same socket straight away. +// +// sa may be nil for a connected socket (tests drive this over an AF_UNIX +// SOCK_SEQPACKET socketpair); on a bound NETLINK_ROUTE socket pass the kernel +// address {Family: AF_NETLINK}. func DumpRtnetlink(fd int, request []byte, sa *unix.SockaddrNetlink, onMsg func(msgType uint16, body []byte) error) error { - if err := unix.Sendto(fd, request, 0, sa); err != nil { + if len(request) < NlMsgHdrSizeCst { + return ErrShortRequest + } + seq := binary.LittleEndian.Uint32(request[8:12]) + + var to unix.Sockaddr + if sa != nil { + to = sa + } + if err := unix.Sendto(fd, request, 0, to); err != nil { return fmt.Errorf("xtcpnl: rtnetlink send: %w", err) } buf := make([]byte, rtnetlinkRecvBufCst) + interrupted := false for { - n, _, err := unix.Recvfrom(fd, buf, 0) + n, from, err := unix.Recvfrom(fd, buf, 0) if err != nil { return fmt.Errorf("xtcpnl: rtnetlink recv: %w", err) } - if n < NlMsgHdrSizeCst { - return ErrShortRecv + if !fromKernel(from) { + continue } - data := buf[:n] - for len(data) >= NlMsgHdrSizeCst { - var h NlMsgHdr - if _, err := DeserializeNlMsgHdr(data, &h); err != nil { - return err - } - msgLen := int(h.Len) - if msgLen < NlMsgHdrSizeCst || msgLen > len(data) { - return ErrBadMsgLen + deliver := onMsg + if interrupted { + deliver = nil // draining only: nothing more is delivered after an interruption + } + done, werr := walkNlMsgs(buf[:n], seq, deliver) + switch { + case errors.Is(werr, ErrDumpInterrupted): + interrupted = true + case werr != nil: + return werr + } + if done { + if interrupted { + return ErrDumpInterrupted } + return nil + } + } +} - switch h.Type { - case uint16(unix.NLMSG_DONE): - return nil - case uint16(unix.NLMSG_ERROR): - return netlinkErr(data[NlMsgHdrSizeCst:msgLen]) - case uint16(unix.NLMSG_NOOP): - // nothing to do - default: - if err := onMsg(h.Type, data[NlMsgHdrSizeCst:msgLen]); err != nil { - return err - } - } +// fromKernel reports whether a datagram's sender address is the kernel. On a +// netlink socket the kernel is always nlmsg_pid 0; a datagram from any other +// netlink port id is a userspace peer and is dropped. A nil or non-netlink +// address (AF_UNIX socketpair in tests) is accepted. +func fromKernel(from unix.Sockaddr) bool { + sn, ok := from.(*unix.SockaddrNetlink) + return !ok || sn.Pid == 0 +} - adv := msgLen + FourByteAlignPadding(msgLen) - if adv <= 0 || adv > len(data) { - break - } +// walkNlMsgs parses one received datagram: a run of 4-byte-aligned netlink +// messages. It is pure (no I/O) so it can be table- and fuzz-tested directly. +// +// Rules, in order, for each message: +// - fewer than 16 bytes in the datagram at all → ErrShortRecv; +// - nlmsg_len < 16 or overrunning the datagram → ErrBadMsgLen; +// - nlmsg_seq != seq → skipped entirely (stale reply, including a stale DONE); +// - NLM_F_DUMP_INTR set → the rest of this datagram is walked but not +// delivered, and the return error is ErrDumpInterrupted (with done set if +// DONE was also reached); +// - NLMSG_DONE → done=true; NLMSG_ERROR → done=true with netlinkErr (nil for +// a zero-errno ACK); NLMSG_NOOP skipped; anything else → onMsg (a nil onMsg +// discards), whose error is returned immediately. +// +// A trailing remainder shorter than a header is ignored, mirroring the +// kernel's NLMSG_OK walk. done=false, err=nil means the dump continues in the +// next datagram. +func walkNlMsgs(data []byte, seq uint32, onMsg func(msgType uint16, body []byte) error) (done bool, err error) { + if len(data) < NlMsgHdrSizeCst { + return false, ErrShortRecv + } + + interrupted := false + for len(data) >= NlMsgHdrSizeCst { + var h NlMsgHdr + if _, derr := DeserializeNlMsgHdr(data, &h); derr != nil { + return false, derr + } + msgLen := int(h.Len) + if msgLen < NlMsgHdrSizeCst || msgLen > len(data) { + return false, ErrBadMsgLen + } + body := data[NlMsgHdrSizeCst:msgLen] + + adv := msgLen + FourByteAlignPadding(msgLen) + if adv > len(data) { + adv = len(data) // last message: padding may legitimately be absent + } + + if h.Seq != seq { data = data[adv:] + continue + } + if h.Flags&uint16(unix.NLM_F_DUMP_INTR) != 0 { + interrupted = true } + + switch h.Type { + case uint16(unix.NLMSG_DONE): + if interrupted { + return true, ErrDumpInterrupted + } + return true, nil + case uint16(unix.NLMSG_ERROR): + if interrupted { + return true, ErrDumpInterrupted + } + return true, netlinkErr(body) + case uint16(unix.NLMSG_NOOP): + // nothing to do + default: + if !interrupted && onMsg != nil { + if cerr := onMsg(h.Type, body); cerr != nil { + return false, cerr + } + } + } + + data = data[adv:] + } + + if interrupted { + return false, ErrDumpInterrupted } + return false, nil } // netlinkErr decodes an NLMSG_ERROR body. The kernel puts a negative errno in diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink_dump_test.go b/pkg/xtcpnl/xtcpnl_rtnetlink_dump_test.go new file mode 100644 index 0000000..8d8306d --- /dev/null +++ b/pkg/xtcpnl/xtcpnl_rtnetlink_dump_test.go @@ -0,0 +1,360 @@ +package xtcpnl + +import ( + "bytes" + "encoding/binary" + "errors" + "syscall" + "testing" + "time" + + "golang.org/x/sys/unix" +) + +// ---- walkNlMsgs / DumpRtnetlink tests ----------------------------------------- +// +// These exercise the dump-stream walker without a kernel: walkNlMsgs is pure and +// takes a datagram, and DumpRtnetlink is driven over an AF_UNIX SOCK_SEQPACKET +// socketpair (each Write is one datagram, exactly like a netlink recv), with +// sa == nil so Sendto goes to the connected peer. + +const testSeq uint32 = 0x1234 + +// nlmsg lays out one netlink message: 16-byte nlmsghdr + body, with the length +// set to the UNPADDED size (the kernel pads the stream, not nlmsg_len). +func nlmsg(typ, flags uint16, seq uint32, body []byte) []byte { + b := make([]byte, NlMsgHdrSizeCst+len(body)) + binary.LittleEndian.PutUint32(b[0:4], uint32(len(b))) + binary.LittleEndian.PutUint16(b[4:6], typ) + binary.LittleEndian.PutUint16(b[6:8], flags) + binary.LittleEndian.PutUint32(b[8:12], seq) + binary.LittleEndian.PutUint32(b[12:16], 0) + copy(b[NlMsgHdrSizeCst:], body) + return b +} + +// pad appends the 4-byte alignment padding the kernel inserts between messages. +func pad(msg []byte) []byte { + return append(msg, make([]byte, FourByteAlignPadding(len(msg)))...) +} + +// stream concatenates messages, padding every one except the last (the kernel +// does not pad the final message of a datagram past its nlmsg_len). +func stream(msgs ...[]byte) []byte { + var out []byte + for i, m := range msgs { + if i < len(msgs)-1 { + out = append(out, pad(m)...) + } else { + out = append(out, m...) + } + } + return out +} + +// errnoBody is an NLMSG_ERROR body: negative errno + echoed request header. +func errnoBody(errno syscall.Errno) []byte { + b := make([]byte, 4+NlMsgHdrSizeCst) + binary.LittleEndian.PutUint32(b[0:4], uint32(-int32(errno))) + return b +} + +var ( + doneMsg = nlmsg(uint16(unix.NLMSG_DONE), uint16(unix.NLM_F_MULTI), testSeq, make([]byte, 4)) + ackMsg = nlmsg(uint16(unix.NLMSG_ERROR), 0, testSeq, errnoBody(0)) + enoentMsg = nlmsg(uint16(unix.NLMSG_ERROR), 0, testSeq, errnoBody(syscall.ENOENT)) + noopMsg = nlmsg(uint16(unix.NLMSG_NOOP), 0, testSeq, nil) + linkA = nlmsg(uint16(unix.RTM_NEWLINK), uint16(unix.NLM_F_MULTI), testSeq, []byte("link-A-body-16bt")) + linkB = nlmsg(uint16(unix.RTM_NEWLINK), uint16(unix.NLM_F_MULTI), testSeq, []byte("link-B-13byte")) // 13-byte body -> 3 bytes padding + linkIntr = nlmsg(uint16(unix.RTM_NEWLINK), uint16(unix.NLM_F_MULTI|unix.NLM_F_DUMP_INTR), testSeq, []byte("intr")) // dump interrupted + staleLink = nlmsg(uint16(unix.RTM_NEWLINK), uint16(unix.NLM_F_MULTI), testSeq+1, []byte("stale")) + staleDone = nlmsg(uint16(unix.NLMSG_DONE), uint16(unix.NLM_F_MULTI), testSeq-1, make([]byte, 4)) +) + +// delivered records what onMsg saw. +type delivered struct { + typ uint16 + body string +} + +func collector(sink *[]delivered, fail error) func(uint16, []byte) error { + return func(mt uint16, body []byte) error { + *sink = append(*sink, delivered{mt, string(body)}) + return fail + } +} + +// go test ./pkg/xtcpnl/ -run TestWalkNlMsgs +func TestWalkNlMsgs(t *testing.T) { + errOnMsg := errors.New("onMsg failed") + + tests := []struct { + description string + data []byte + onMsgErr error // returned by onMsg on every call + wantDone bool // expected done + wantErr error // expected errors.Is target (nil = no error) + wantMsgs []delivered // expected onMsg deliveries, in order + }{ + // positive + {"one RTM_NEWLINK then DONE -> delivered once, done", stream(linkA, doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"DONE alone -> done, nothing delivered", stream(doneMsg), nil, true, nil, nil}, + {"zero-errno ACK -> done, nil (not an error)", stream(ackMsg), nil, true, nil, nil}, + {"two messages, second body 13 bytes (padding) -> both delivered at aligned offsets", stream(linkB, linkA, doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-B-13byte"}, {uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"datagram without DONE -> not done, no error (dump continues in next recv)", stream(linkA, linkB), nil, false, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}, {uint16(unix.RTM_NEWLINK), "link-B-13byte"}}}, + {"NOOP is skipped, following message delivered", stream(noopMsg, linkA, doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"nil onMsg discards payload messages but still reaches DONE", stream(linkA, doneMsg), nil, true, nil, nil}, + + // negative + {"non-zero errno NLMSG_ERROR -> done, wrapped ENOENT", stream(enoentMsg), nil, true, syscall.ENOENT, nil}, + {"NLMSG_ERROR body shorter than errno -> ErrNetlinkError", + stream(nlmsg(uint16(unix.NLMSG_ERROR), 0, testSeq, []byte{0xff, 0xff})), nil, true, ErrNetlinkError, nil}, + {"onMsg error is returned immediately, later messages not delivered", stream(linkA, linkB, doneMsg), errOnMsg, false, errOnMsg, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + + // boundary + {"empty datagram -> ErrShortRecv", nil, nil, false, ErrShortRecv, nil}, + {"15-byte datagram -> ErrShortRecv", make([]byte, 15), nil, false, ErrShortRecv, nil}, + {"nlmsg_len 15 (< header) -> ErrBadMsgLen", func() []byte { + m := nlmsg(uint16(unix.RTM_NEWLINK), 0, testSeq, nil) + binary.LittleEndian.PutUint32(m[0:4], 15) + return m + }(), nil, false, ErrBadMsgLen, nil}, + {"nlmsg_len overruns datagram -> ErrBadMsgLen", func() []byte { + m := nlmsg(uint16(unix.RTM_NEWLINK), 0, testSeq, []byte("abcd")) + binary.LittleEndian.PutUint32(m[0:4], uint32(len(m)+8)) + return m + }(), nil, false, ErrBadMsgLen, nil}, + {"trailing remainder shorter than a header is ignored", append(stream(linkA), 1, 2, 3), nil, false, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"bare header, zero-length body, then DONE", stream(nlmsg(uint16(unix.RTM_NEWLINK), 0, testSeq, nil), doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), ""}}}, + + // corner — sequence filtering + {"stale-seq message skipped, matching message delivered", stream(staleLink, linkA, doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"stale-seq DONE does not end the dump", stream(staleDone, linkA), nil, false, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"stale-seq NLMSG_ERROR is ignored too", stream(nlmsg(uint16(unix.NLMSG_ERROR), 0, testSeq+7, errnoBody(syscall.EPERM)), doneMsg), nil, true, nil, nil}, + + // corner — NLM_F_DUMP_INTR + {"DUMP_INTR message -> ErrDumpInterrupted, not done, nothing after it delivered", stream(linkA, linkIntr, linkB), nil, false, ErrDumpInterrupted, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"DUMP_INTR then DONE in same datagram -> done AND ErrDumpInterrupted", stream(linkIntr, doneMsg), nil, true, ErrDumpInterrupted, nil}, + {"DUMP_INTR flag on the DONE itself -> done AND ErrDumpInterrupted", + stream(linkA, nlmsg(uint16(unix.NLMSG_DONE), uint16(unix.NLM_F_MULTI|unix.NLM_F_DUMP_INTR), testSeq, make([]byte, 4))), nil, true, ErrDumpInterrupted, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"DUMP_INTR on a stale-seq message is ignored (belongs to another dump)", + stream(nlmsg(uint16(unix.RTM_NEWLINK), uint16(unix.NLM_F_DUMP_INTR), testSeq+1, []byte("x")), linkA, doneMsg), nil, true, nil, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var got []delivered + var onMsg func(uint16, []byte) error + if tc.description != "nil onMsg discards payload messages but still reaches DONE" { + onMsg = collector(&got, tc.onMsgErr) + } + done, err := walkNlMsgs(tc.data, testSeq, onMsg) + if done != tc.wantDone { + t.Errorf("done = %v, want %v", done, tc.wantDone) + } + if tc.wantErr == nil && err != nil { + t.Errorf("err = %v, want nil", err) + } + if tc.wantErr != nil && !errors.Is(err, tc.wantErr) { + t.Errorf("err = %v, want errors.Is(%v)", err, tc.wantErr) + } + if len(got) != len(tc.wantMsgs) { + t.Fatalf("delivered %d messages %v, want %d %v", len(got), got, len(tc.wantMsgs), tc.wantMsgs) + } + for i := range got { + if got[i] != tc.wantMsgs[i] { + t.Errorf("delivered[%d] = %+v, want %+v", i, got[i], tc.wantMsgs[i]) + } + } + }) + } +} + +// FuzzWalkNlMsgs asserts the walker never panics and never hands onMsg a body +// that is not a sub-slice of the input, for any byte soup. +// +// go test ./pkg/xtcpnl/ -run '^$' -fuzz FuzzWalkNlMsgs -fuzztime 20s +func FuzzWalkNlMsgs(f *testing.F) { + for _, seed := range [][]byte{ + nil, + stream(linkA, doneMsg), + stream(linkB, linkA), + stream(enoentMsg), + stream(linkIntr, doneMsg), + stream(staleDone, linkA, doneMsg), + make([]byte, 15), + make([]byte, 16), + } { + f.Add(seed, testSeq) + } + f.Fuzz(func(t *testing.T, data []byte, seq uint32) { + done, err := walkNlMsgs(data, seq, func(_ uint16, body []byte) error { + if len(body) > len(data) { + t.Fatalf("body longer than input: %d > %d", len(body), len(data)) + } + return nil + }) + if len(data) < NlMsgHdrSizeCst && !errors.Is(err, ErrShortRecv) { + t.Fatalf("short input must yield ErrShortRecv, got done=%v err=%v", done, err) + } + }) +} + +// seqpacketPair returns a connected AF_UNIX SOCK_SEQPACKET socketpair, closed at +// test end. fds[0] plays the daemon side (DumpRtnetlink), fds[1] the "kernel". +func seqpacketPair(t *testing.T) [2]int { + t.Helper() + fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_SEQPACKET|unix.SOCK_CLOEXEC, 0) + if err != nil { + t.Fatalf("Socketpair: %v", err) + } + tv := unix.Timeval{Sec: 2} + if err := unix.SetsockoptTimeval(fds[0], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &tv); err != nil { + t.Fatalf("SO_RCVTIMEO: %v", err) + } + t.Cleanup(func() { + _ = unix.Close(fds[0]) + _ = unix.Close(fds[1]) + }) + return [2]int{fds[0], fds[1]} +} + +// go test ./pkg/xtcpnl/ -run TestDumpRtnetlinkSocketpair +func TestDumpRtnetlinkSocketpair(t *testing.T) { + request := BuildDumpLinkRequest(testSeq) + + tests := []struct { + description string + request []byte + replies [][]byte // datagrams the fake kernel writes after reading the request + closeAfter bool // fake kernel closes its end after writing replies (EOF) + wantErr error // errors.Is target; nil = success + wantSent bool // expected: the request reached the peer + wantMsgs []delivered + }{ + // positive + {"two datagrams then DONE -> both bodies, nil", request, + [][]byte{stream(linkA), stream(linkB, doneMsg)}, false, nil, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}, {uint16(unix.RTM_NEWLINK), "link-B-13byte"}}}, + {"single datagram carrying DONE -> nil", request, [][]byte{stream(linkA, doneMsg)}, false, nil, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"zero-errno ACK ends the dump cleanly", request, [][]byte{stream(ackMsg)}, false, nil, true, nil}, + {"stale-seq DONE datagram skipped, real DONE later", request, + [][]byte{stream(staleLink, staleDone), stream(linkA, doneMsg)}, false, nil, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + + // negative + {"NLMSG_ERROR ENOENT -> wrapped errno", request, [][]byte{stream(enoentMsg)}, false, syscall.ENOENT, true, nil}, + {"peer closes without DONE -> EOF surfaces as ErrShortRecv", request, [][]byte{stream(linkA)}, true, ErrShortRecv, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + {"malformed nlmsg_len in second datagram -> ErrBadMsgLen", request, + [][]byte{stream(linkA), func() []byte { + m := nlmsg(uint16(unix.RTM_NEWLINK), 0, testSeq, []byte("abcd")) + binary.LittleEndian.PutUint32(m[0:4], 200) + return m + }()}, false, ErrBadMsgLen, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + + // boundary + {"request shorter than nlmsghdr -> ErrShortRequest, nothing sent", request[:NlMsgHdrSizeCst-1], nil, false, ErrShortRequest, false, nil}, + + // corner — interruption is drained to DONE before being reported + {"DUMP_INTR in first datagram, DONE two datagrams later -> ErrDumpInterrupted after drain", request, + [][]byte{stream(linkA, linkIntr), stream(linkB), stream(doneMsg)}, false, ErrDumpInterrupted, true, + []delivered{{uint16(unix.RTM_NEWLINK), "link-A-body-16bt"}}}, + } + + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + fds := seqpacketPair(t) + + // Fake kernel: read the request, verify it, then script the replies. + sentCh := make(chan []byte, 1) + go func() { + defer func() { + if tc.closeAfter { + _ = unix.Close(fds[1]) + } + }() + if !tc.wantSent { + return + } + rb := make([]byte, 256) + n, _, err := unix.Recvfrom(fds[1], rb, 0) + if err != nil { + sentCh <- nil + return + } + sentCh <- rb[:n] + for _, d := range tc.replies { + if _, err := unix.Write(fds[1], d); err != nil { + return + } + } + }() + + var got []delivered + err := DumpRtnetlink(fds[0], tc.request, nil, collector(&got, nil)) + + if tc.wantErr == nil && err != nil { + t.Errorf("err = %v, want nil", err) + } + if tc.wantErr != nil && !errors.Is(err, tc.wantErr) { + t.Errorf("err = %v, want errors.Is(%v)", err, tc.wantErr) + } + if tc.wantSent { + select { + case sent := <-sentCh: + if !bytes.Equal(sent, tc.request) { + t.Errorf("peer received %x, want the request %x", sent, tc.request) + } + case <-time.After(2 * time.Second): + t.Error("peer never received the request") + } + } + if len(got) != len(tc.wantMsgs) { + t.Fatalf("delivered %d messages %v, want %d %v", len(got), got, len(tc.wantMsgs), tc.wantMsgs) + } + for i := range got { + if got[i] != tc.wantMsgs[i] { + t.Errorf("delivered[%d] = %+v, want %+v", i, got[i], tc.wantMsgs[i]) + } + } + }) + } +} + +// TestFromKernel covers the sender-pid filter in isolation. +// +// go test ./pkg/xtcpnl/ -run TestFromKernel +func TestFromKernel(t *testing.T) { + tests := []struct { + description string + from unix.Sockaddr + want bool + }{ + {"netlink pid 0 (kernel) -> accepted", &unix.SockaddrNetlink{Family: unix.AF_NETLINK}, true}, + {"netlink pid 4242 (userspace peer) -> rejected", &unix.SockaddrNetlink{Family: unix.AF_NETLINK, Pid: 4242}, false}, + {"nil address (connected socket) -> accepted", nil, true}, + {"AF_UNIX address (socketpair) -> accepted", &unix.SockaddrUnix{Name: "@x"}, true}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + if got := fromKernel(tc.from); got != tc.want { + t.Errorf("fromKernel(%+v) = %v, want %v", tc.from, got, tc.want) + } + }) + } +} diff --git a/pkg/xtcpnl/xtcpnl_rtnetlink_test.go b/pkg/xtcpnl/xtcpnl_rtnetlink_test.go index 282e49f..3268c41 100644 --- a/pkg/xtcpnl/xtcpnl_rtnetlink_test.go +++ b/pkg/xtcpnl/xtcpnl_rtnetlink_test.go @@ -424,6 +424,61 @@ func TestParseNewRoute(t *testing.T) { Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, Dst: v4b(10, 0, 0, 0), }, }, + { + // An ECMP route carries its per-path gateways/interfaces inside + // RTA_MULTIPATH and has no top-level RTA_GATEWAY/RTA_OIF. Only the + // presence is recorded; the nested nexthops are not parsed. + description: "positive: ECMP route flags HasMultipath (RTA_MULTIPATH present, no RTA_GATEWAY)", + body: concat( + rtmsgHdr(unix.AF_INET, 16, 0, unix.RT_TABLE_MAIN, unix.RTPROT_BOOT, unix.RT_SCOPE_UNIVERSE, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 20, 0, 0)), + rtattr(unix.RTA_MULTIPATH, make([]byte, 16)), // two opaque rtnexthop blobs + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 16, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_BOOT, + Dst: v4b(10, 20, 0, 0), HasMultipath: true, + }, + }, + { + description: "positive: IPv4 route via an IPv6 gateway flags HasVia (RTA_VIA, no RTA_GATEWAY)", + body: concat( + rtmsgHdr(unix.AF_INET, 16, 0, unix.RT_TABLE_MAIN, unix.RTPROT_BOOT, unix.RT_SCOPE_UNIVERSE, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 30, 0, 0)), + rtattr(unix.RTA_VIA, append([]byte{byte(unix.AF_INET6), 0}, mustV6(t, "fe80::1")...)), // struct rtvia{family, addr} + rtattr(unix.RTA_OIF, le32(2)), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 16, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_BOOT, + Dst: v4b(10, 30, 0, 0), Oif: 2, HasVia: true, + }, + }, + { + description: "positive: route pointing at a nexthop object carries NhID (RTA_NH_ID, no RTA_GATEWAY/RTA_OIF)", + body: concat( + rtmsgHdr(unix.AF_INET, 16, 0, unix.RT_TABLE_MAIN, unix.RTPROT_BOOT, unix.RT_SCOPE_UNIVERSE, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 40, 0, 0)), + rtattr(RtaNhID, le32(5)), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 16, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Protocol: unix.RTPROT_BOOT, + Dst: v4b(10, 40, 0, 0), NhID: 5, + }, + }, + { + description: "corner: short RTA_NH_ID (2 bytes) is ignored, leaving NhID zero", + body: concat( + rtmsgHdr(unix.AF_INET, 16, 0, unix.RT_TABLE_MAIN, 0, unix.RT_SCOPE_UNIVERSE, unix.RTN_UNICAST, 0), + rtattr(unix.RTA_DST, v4b(10, 40, 0, 0)), + rtattr(RtaNhID, []byte{0x05, 0x00}), + ), + want: RouteInfo{ + Family: unix.AF_INET, DstLen: 16, Table: unix.RT_TABLE_MAIN, + Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Dst: v4b(10, 40, 0, 0), + }, + }, { description: "corner: truncated rtmsg header -> error", body: make([]byte, RtMsgSizeCst-1), diff --git a/proto/xtcp_config/v1/xtcp_config.proto b/proto/xtcp_config/v1/xtcp_config.proto index 5c6cca4..023cd98 100644 --- a/proto/xtcp_config/v1/xtcp_config.proto +++ b/proto/xtcp_config/v1/xtcp_config.proto @@ -1,8 +1,8 @@ // // xTCP - config // -// These are all the structs relating to the TCP diagnotic module in the kernel -// +// Runtime configuration of the xtcp2 daemon, served and mutated over gRPC +// (ConfigService) and mirrored one-to-one by the cmd/xtcp2 CLI flags / env. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder @@ -261,8 +261,29 @@ message SetEnvelopeFlushResponse { }; // xtcp configuration +// +// Field-number layout (renumbered into subject blocks 2026-09; the binary form +// is never persisted — it only crosses the gRPC hop between xtcp2 and +// xtcp2ctl/xtcp2client, which are built from this repo's gen/go together, and +// protojson/prototext map by NAME — so renumbering is safe). Add new knobs in +// the free space of the matching block; open a new block above 250 for a new +// subject. +// 10-39 polling & netlink (dump cadence, netlinker plumbing, io_uring) +// 40-49 namespace reconcile +// 50-59 capture / debug +// 60-79 output, destination-agnostic (dest, marshal, csv, envelope) +// 80-99 kafka destination +// 100-129 s3parquet destination +// 130-149 identity & labels stamped on every record +// 150-159 network knobs for xtcp2's own listeners +// 160-169 gRPC +// 170-179 profiling +// 200-249 best-effort enrichment (container 200s, lldp 210s, nic 220s, +// nsid 230s, asn 240-244, locality 245-249) message XtcpConfig { + // ---- polling & netlink (10-39) -------------------------------------------- + // Netlink socket timeout in milliseconds // Recommend 5000 uint64 nl_timeout_milliseconds = 10 [ @@ -276,7 +297,7 @@ message XtcpConfig { // This is how often xtcp sends the netlink dump request // Recommend not too frequently, so maybe 30s or 60s // https://pkg.go.dev/google.golang.org/protobuf/types/known/durationpb - google.protobuf.Duration poll_frequency = 20 [ + google.protobuf.Duration poll_frequency = 11 [ (buf.validate.field).required = true, (buf.validate.field).duration = { gt: { @@ -289,7 +310,7 @@ message XtcpConfig { // Poll timeout per name space // Must be less than the poll frequency - google.protobuf.Duration poll_timeout = 30 [ + google.protobuf.Duration poll_timeout = 12 [ (buf.validate.field).required = true, (buf.validate.field).duration = { gt: { @@ -306,8 +327,18 @@ message XtcpConfig { expression: "this.poll_frequency > this.poll_timeout" }; + // Maximum poll-schedule jitter as a percent of poll_frequency, applied to + // both the startup delay before the first poll and each subsequent tick. + // 0 disables (immediate first poll, fixed interval). Default 20. See + // docs/design-jitter-and-backoff.md. + uint32 poll_jitter_pct = 13 [ + (buf.validate.field).required = false, + (buf.validate.field).uint32 = { + lte: 100 + }]; + // Maximum number of loops, or zero (0) for forever - uint64 max_loops = 40 [ + uint64 max_loops = 14 [ (buf.validate.field).required = false, (buf.validate.field).uint64 = { gte: 0, @@ -317,26 +348,26 @@ message XtcpConfig { // Netlinker goroutines per netlink socket ( recommend 1,2,4 range ) // Netlinkers read the tcp-diag response messages from the netlink socket // If you have a large number of - uint32 netlinkers = 50 [ + uint32 netlinkers = 15 [ (buf.validate.field).required = true, (buf.validate.field).uint32 = { gte: 1, lte: 100 }]; - // netlinkerDoneCh channel size - // This channel is used between the netlinkers and the poller - // Check the prom counter to see if the channel is too small - // d.pC.WithLabelValues("Deserialize", "netlinkerDoneCh", "error").Inc() - uint32 netlinkers_done_chan_size = 51 [ - (buf.validate.field).required = true, - (buf.validate.field).uint32 = { - gte: 1, - lte: 1000 - }]; + // netlinkerDoneCh channel size + // This channel is used between the netlinkers and the poller + // Check the prom counter to see if the channel is too small + // d.pC.WithLabelValues("Deserialize", "netlinkerDoneCh", "error").Inc() + uint32 netlinkers_done_chan_size = 16 [ + (buf.validate.field).required = true, + (buf.validate.field).uint32 = { + gte: 1, + lte: 1000 + }]; // nlmsg_seq sequence number (start). This gets incremented. - uint32 nlmsg_seq = 60 [ + uint32 nlmsg_seq = 17 [ (buf.validate.field).required = true, (buf.validate.field).uint32 = { gte: 0, @@ -345,7 +376,7 @@ message XtcpConfig { // netlinker packetSize. buffer size = packetSize * packetSizeMply. Use zero (0) for syscall.Getpagesize() // recommend using 0 - uint64 packet_size = 70 [ + uint64 packet_size = 18 [ (buf.validate.field).required = false, (buf.validate.field).uint64 = { gte: 0, @@ -353,17 +384,86 @@ message XtcpConfig { }]; // netlinker packetSize multiplier. buffer size = packetSize * packetSizeMply - uint32 packet_size_mply = 80 [ + uint32 packet_size_mply = 19 [ (buf.validate.field).required = false, (buf.validate.field).uint32 = { gte: 0, lte: 100 }]; + // modulus. Report every X socket diag messages to output + uint64 modulus = 20 [ + (buf.validate.field).required = true, + (buf.validate.field).uint64 = { + gte: 1, + lte: 1000000 + }]; + + // Which INET_DIAG_* extension deserializers run (keyed by short name: + // info, skmem, cong, tos, tc, shut, vegas, dctcp, bbr, classid, sockopt, + // cgroup, meminfo). Unset = daemon defaults. + EnabledDeserializers enabled_deserializers = 21 [ + (buf.validate.field).required = false + ]; + + // When true, route netlink reads and raw-socket destination writes + // through an io_uring ring per Netlinker. Requires Linux 6.1+. + // Library-backed destinations (kafka, nsq, nats, valkey) ignore this + // flag — they continue to use their own client sockets unchanged. + bool io_uring = 22 [ + (buf.validate.field).required = false + ]; + + // Number of recvmsg SQEs kept in flight per Netlinker ring. Higher + // values reduce io_uring_enter syscalls per dump cycle on hosts with + // many sockets, at the cost of more pinned buffers from packet pool. + // Ignored unless io_uring=true. Default 64. + uint32 io_uring_recv_batch_size = 23 [ + (buf.validate.field).required = false, + (buf.validate.field).uint32 = { + gte: 1, + lte: 4096 + }]; + + // Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise + // userland loop overhead but increase scheduling latency for the + // netlinker goroutine. Ignored unless io_uring=true. Default 128. + uint32 io_uring_cqe_batch_size = 24 [ + (buf.validate.field).required = false, + (buf.validate.field).uint32 = { + gte: 1, + lte: 4096 + }]; + + // ---- namespace reconcile (40-49) ----------------------------------------- + + // Period of the background namespace-reconcile ticker (Method B /proc scan + // that converges the tracked namespace set). With reconcile_before_poll the + // Poller reconciles every cycle and is the real discovery mechanism, so this + // background pass is an occasional safety-net expected to find nothing + // (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) + // so operators can confirm from the counters that it is redundant. It still + // matters when the poller is idle or disabled. 0 disables the background + // ticker entirely (the startup reconcile still runs once). + google.protobuf.Duration reconcile_frequency = 40 [ + (buf.validate.field).required = false, + (buf.validate.field).duration = { + gte: { seconds: 0 } + }]; + + // Run a namespace reconcile immediately before each poll cycle, so a + // namespace that appeared since the last cycle is entered and gets a socket + // within ~1 poll interval instead of waiting for the background ticker. Ties + // discovery cadence to poll cadence; the /proc scan is zero-allocation and + // mutex-serialized with the background reconciler. Default true. + bool reconcile_before_poll = 41; + + // ---- capture / debug (50-59) --------------------------------------------- + // Write netlink packets to writeFiles number of files ( to generate test data ) per netlinker // xtcp will capture this many Netlink response packets when it starts // This is PER netlinker - uint32 write_files = 90 [ + uint32 write_files = 50 [ (buf.validate.field).required = false, (buf.validate.field).uint32 = { gte: 0, @@ -371,29 +471,73 @@ message XtcpConfig { }]; // Write files path - string capture_path = 100 [ + string capture_path = 51 [ (buf.validate.field).required = false, (buf.validate.field).string = { min_len: 1, max_len: 80, }]; - // modulus. Report every X socket diag messages to output - uint64 modulus = 110 [ + // Write marshalled data to dest_write_files number of files ( to allow debugging of the serialization ) + // xtcp will capture this many examples of the marshalled data + // This is PER poller + uint32 dest_write_files = 52 [ + (buf.validate.field).required = false, + (buf.validate.field).uint32 = { + gte: 0, + lte: 1000 + }]; + + // DebugLevel + uint32 debug_level = 53 [ (buf.validate.field).required = true, - (buf.validate.field).uint64 = { - gte: 1, - lte: 1000000 + (buf.validate.field).uint32 = { + gte: 0, + lte: 1000 + }]; + + // ---- output, destination-agnostic (60-79) -------------------------------- + + // kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, + // nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, + // unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or + // unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). + // max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the + // http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES + // and S3 endpoints the INSERT query + FORMAT + format_schema + auth query + // params routinely run ~150+ chars, which the old 128 cap rejected. + string dest = 60 [ + (buf.validate.field).required = true, + (buf.validate.field).string = { + min_len: 4, + max_len: 512, }]; // Marshalling of the exported data (protobufList,json,prototext) - string marshal_to = 120 [ + string marshal_to = 61 [ (buf.validate.field).required = true, (buf.validate.field).string = { min_len: 3, max_len: 40, }]; + // Comma-separated subset of XtcpFlatRecord json field names selecting + // which columns the csv/tsv marshallers emit (e.g. + // "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). + // Empty = all fields. Ignored by non-tabular marshallers. + string csv_columns = 62 [ + (buf.validate.field).required = false + ]; + + // XtcpProtoFile — path of the xtcp_flat_record.proto the daemon reads at + // startup and POSTs to the Kafka schema registry (kafka_schema_url). + string xtcp_proto_file = 63 [ + (buf.validate.field).required = false, + (buf.validate.field).string = { + min_len: 1, + max_len: 80, + }]; + // Soft cap on the in-flight envelope's marshalled size, in bytes. // Measured via proto.Size — i.e. the UNCOMPRESSED serialized size. // franz-go applies ZSTD/LZ4/Snappy compression after handoff, so the @@ -406,7 +550,7 @@ message XtcpConfig { // Useful primarily as a safety net against records with huge // `bytes` fields. For everyday batch sizing, prefer the row-count // cap (envelope_flush_threshold_rows) below. - uint32 envelope_flush_threshold_bytes = 122 [ + uint32 envelope_flush_threshold_bytes = 64 [ (buf.validate.field).required = false ]; @@ -420,10 +564,42 @@ message XtcpConfig { // (EnvelopeFlushThresholdRowsCst, currently 10000 — chosen to align // with the ClickHouse kafka_max_rows_per_message setting so a // produced envelope never forces the consumer to split it). - uint32 envelope_flush_threshold_rows = 123 [ + uint32 envelope_flush_threshold_rows = 65 [ (buf.validate.field).required = false ]; + // ---- kafka destination (80-99) ------------------------------------------- + + // Kafka or NSQ topic + string topic = 80 [ + (buf.validate.field).required = false, + (buf.validate.field).string = { + min_len: 1, + max_len: 40, + }]; + + // Kafka schema registry url + string kafka_schema_url = 81 [ + (buf.validate.field).required = false, + (buf.validate.field).string = { + min_len: 1, + max_len: 60, + }]; + + // Kafka Produce context timeout. Use 0 for no context timeout + // Recommend a small timeout, like 1-2 seconds + // kgo seems to have a bug, because the timeout is always expired + google.protobuf.Duration kafka_produce_timeout = 82 [ + (buf.validate.field).required = false, + (buf.validate.field).duration = { + gte: { + seconds: 0 + } + lte: { + seconds: 600 // 600s = 10 minutes + } + }]; + // Kafka producer-batch compression codec. franz-go picks one codec // from the supplied preference list that the broker advertises. // Both Redpanda and ClickHouse (via librdkafka on its Kafka engine) @@ -442,62 +618,52 @@ message XtcpConfig { // // Pick "lz4" if xtcp2 is CPU-bound on the producer side; pick // "zstd" (the default) if Kafka throughput / disk usage matters more. - string kafka_compression = 124 [ + string kafka_compression = 83 [ (buf.validate.field).required = false ]; - // ─── s3parquet destination ─── + // ---- s3parquet destination (100-129) ------------------------------------- // - // Endpoint, bucket, credentials, and tuning for the s3parquet - // destination. Effective only when -dest s3parquet:... is in use. + // Endpoint, bucket, credentials (100-109), then flush / jitter / upload + // tuning (110-129). Effective only when -dest s3parquet:... is in use. // If s3_endpoint is empty and -dest is `s3parquet:`, the // daemon parses the address from the -dest URL instead. // S3 endpoint URL, e.g. "http://127.0.0.1:9000" (MinIO) or // "https://s3.amazonaws.com" (AWS). May be empty if -dest carries // it via the s3parquet: form. - string s3_endpoint = 125 [ + string s3_endpoint = 100 [ + (buf.validate.field).required = false + ]; + + // S3 region. Required by some S3 implementations even when talking + // to a single-region MinIO. Default "us-east-1" when blank. + string s3_region = 101 [ (buf.validate.field).required = false ]; // Required when -dest s3parquet. Bucket must already exist on the // endpoint; the daemon does not auto-create. - string s3_bucket = 126 [ + string s3_bucket = 102 [ (buf.validate.field).required = false ]; // Optional key-prefix WITHIN the bucket. Joined with the Hive-style // partition segments (host=…/date=…/hour=…/.parquet). Empty // = files land at the bucket root level. - string s3_prefix = 127 [ + string s3_prefix = 103 [ (buf.validate.field).required = false ]; // Required when -dest s3parquet. Picked up from AWS_ACCESS_KEY_ID // env if blank. - string s3_access_key = 128 [ + string s3_access_key = 104 [ (buf.validate.field).required = false ]; // Required when -dest s3parquet. Picked up from AWS_SECRET_ACCESS_KEY // env if blank. Never logged. - string s3_secret_key = 129 [ - (buf.validate.field).required = false - ]; - - // Soft cap on the in-memory Parquet builder's accumulated - // uncompressed row bytes before the worker finalizes the file and - // uploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst). - // Operators tune down for faster file rotation (more S3 PUTs, - // smaller per-file query latency) or up for fewer larger files - // (better compression ratio, more memory). - uint32 s3_parquet_flush_threshold_bytes = 132 [ - (buf.validate.field).required = false - ]; - - // S3 region. Required by some S3 implementations even when talking - // to a single-region MinIO. Default "us-east-1" when blank. - string s3_region = 133 [ + string s3_secret_key = 105 [ (buf.validate.field).required = false ]; @@ -507,115 +673,94 @@ message XtcpConfig { // only (write-only key, e.g. a baked deployment credential) so the // daemon can start without list permission. Default false keeps the // fail-fast probe for normal deployments. - bool s3_skip_bucket_probe = 134 [ - (buf.validate.field).required = false - ]; - - // Pyroscope continuous-profiling server URL (e.g. - // http://127.0.0.1:4040). When set, the daemon streams CPU, - // memory, goroutine, mutex, and block profiles to that endpoint. - // Empty disables the agent — no overhead in production runs that - // don't need it. Operators bring up a Pyroscope OSS server (or - // Grafana Cloud Pyroscope) and point xtcp2 at it for live profile - // data without restarts. - string pyroscope_url = 136 [ + bool s3_skip_bucket_probe = 106 [ (buf.validate.field).required = false ]; - // Application name registered with the Pyroscope server (the - // "application" facet in the Pyroscope UI). Empty → "xtcp2". - // Set per fleet/role for multi-host environments - // (e.g. "xtcp2.prod.iad", "xtcp2.staging.fra"). - string pyroscope_app_name = 137 [ + // Soft cap on the in-memory Parquet builder's accumulated + // uncompressed row bytes before the worker finalizes the file and + // uploads. Default 0 → 63 MiB (S3ParquetFlushThresholdBytesCst). + // Operators tune down for faster file rotation (more S3 PUTs, + // smaller per-file query latency) or up for fewer larger files + // (better compression ratio, more memory). + uint32 s3_parquet_flush_threshold_bytes = 110 [ (buf.validate.field).required = false ]; - // CPU profile sampling rate in Hz. Default 100. The Pyroscope - // agent uses this to call runtime.SetCPUProfileRate at startup. - uint32 pyroscope_sample_hz = 138 [ - (buf.validate.field).required = false - ]; + // s3parquet staleness ceiling: force-flush the in-memory Parquet object + // after this long even if it hasn't reached the byte cap, bounding upload + // latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). + google.protobuf.Duration s3_flush_interval = 111 [ + (buf.validate.field).required = false, + (buf.validate.field).duration = { + gte: { seconds: 0 } + }]; - // Profile upload interval (seconds between batched profile - // pushes). Default 15 s. - uint32 pyroscope_upload_interval_sec = 139 [ - (buf.validate.field).required = false - ]; + // Fleet jitter & upload backoff (thundering-herd avoidance). See + // docs/design-jitter-and-backoff.md. All jitter is disabled by setting + // the relevant *_jitter_pct to 0, restoring deterministic behavior. - // kafka:127.0.0.1:9092, udp:127.0.0.1:13000, nsq:127.0.0.1:4150, - // nats:nats://127.0.0.1:4222, valkey:127.0.0.1:6379, null:, - // unix:/path/to/sock (SOCK_STREAM, length-prefixed via varint), or - // unixgram:/path/to/sock (SOCK_DGRAM, one record per datagram). - // max_len 512: a unix sun_path needs ~117 bytes (unixgram: + 108), but the - // http(s) destination carries a full URL — for ClickHouse/Loki/Splunk/ES - // and S3 endpoints the INSERT query + FORMAT + format_schema + auth query - // params routinely run ~150+ chars, which the old 128 cap rejected. - string dest = 130 [ - (buf.validate.field).required = true, - (buf.validate.field).string = { - min_len: 4, - max_len: 512, + // Maximum jitter as a percent of s3_flush_interval, applied to the first + // timed flush and each interval so the fleet doesn't ceiling-flush in + // lockstep. 0 disables. Default 20. + uint32 s3_flush_jitter_pct = 112 [ + (buf.validate.field).required = false, + (buf.validate.field).uint32 = { + lte: 100 }]; - // Write marhselled data to writeFiles number of files ( to allow debugging of the serialization ) - // xtcp will capture this many examples of the marshalled data - // This is PER poller - uint32 dest_write_files = 135 [ + // Per-object downward jitter as a percent of the s3parquet byte cap: each + // object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the + // size-cap upload path even under uniform load. Downward-only, so an + // object never exceeds the in-memory byte bound. 0 disables. Default 20. + uint32 s3_flush_threshold_jitter_pct = 113 [ (buf.validate.field).required = false, (buf.validate.field).uint32 = { - gte: 0, - lte: 1000 + lte: 100 }]; - - // Kafka or NSQ topic - string topic = 140 [ + // Maximum S3 upload attempts (original + retries) before dropping the + // object. Retries use full-jitter exponential backoff. Default 10. + uint32 s3_upload_max_attempts = 114 [ (buf.validate.field).required = false, - (buf.validate.field).string = { - min_len: 1, - max_len: 40, + (buf.validate.field).uint32 = { + gte: 1, + lte: 100 }]; - // XtcpProtoFile - string xtcp_proto_file = 143 [ + // Cap on a single upload retry's backoff window (full jitter draws in + // [0, window], window grows exponentially up to this cap). 0 = derive as + // clamp(poll_frequency/10, 1s, 1h). + google.protobuf.Duration s3_upload_backoff_cap = 115 [ (buf.validate.field).required = false, - (buf.validate.field).string = { - min_len: 1, - max_len: 80, + (buf.validate.field).duration = { + gte: { seconds: 0 } }]; - // Kafka schema registry url - string kafka_schema_url = 145 [ + // ---- identity & labels stamped on every record (130-149) ----------------- + + // Hostname override. When empty the daemon uses os.Hostname(); set this to + // stamp an explicit hostname on records — required in containers, where + // os.Hostname() returns the container id, not the host. Set via -hostname + // flag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the + // container id). + string hostname = 130 [ (buf.validate.field).required = false, (buf.validate.field).string = { - min_len: 1, - max_len: 60, + max_len: 253, }]; - // Kafka Produce context timeout. Use 0 for no context timeout - // Recommend a small timeout, like 1-2 seconds - // kgo seems to have a bug, because the timeout is always expired - google.protobuf.Duration kafka_produce_timeout = 150 [ + // Deployment grouping / facility this daemon runs in (data center, PoP, + // region, site, …). Generic; stamped on every record's `location` field. + // Set via -location flag or LOCATION env. + string location = 131 [ (buf.validate.field).required = false, - (buf.validate.field).duration = { - gte: { - seconds: 0 - } - lte: { - seconds: 600 // 600s = 10 minutes - } - }]; - - // DebugLevel - uint32 debug_level = 160 [ - (buf.validate.field).required = true, - (buf.validate.field).uint32 = { - gte: 0, - lte: 1000 + (buf.validate.field).string = { + max_len: 253, }]; // Label applied to the protobuf - string label = 170 [ + string label = 132 [ (buf.validate.field).required = false, (buf.validate.field).string = { // min_len: 1, @@ -623,57 +768,31 @@ message XtcpConfig { }]; // Tag applied to the protobuf - string tag = 180 [ + string tag = 133 [ (buf.validate.field).required = false, (buf.validate.field).string = { // min_len: 1, max_len: 40, }]; - // Deployment grouping / facility this daemon runs in (data center, PoP, - // region, site, …). Generic; stamped on every record's `location` field. - // Set via -location flag or LOCATION env. - string location = 181 [ - (buf.validate.field).required = false, - (buf.validate.field).string = { - max_len: 253, - }]; - - // Hostname override. When empty the daemon uses os.Hostname(); set this to - // stamp an explicit hostname on records — required in containers, where - // os.Hostname() returns the container id, not the host. Set via -hostname - // flag or XTCP_HOSTNAME env (NOT HOSTNAME, which Docker sets to the - // container id). - string hostname = 182 [ - (buf.validate.field).required = false, - (buf.validate.field).string = { - max_len: 253, - }]; - // Daemon build provenance stamped on every record's `daemon_version` field // (git commit / date / version). Populated by the daemon from -ldflags build // vars, not a user flag; informational only (debugging which binary produced a // row). See XtcpFlatRecord.daemon_version. - string daemon_version = 186 [ + string daemon_version = 134 [ (buf.validate.field).required = false, (buf.validate.field).string = { max_len: 253, }]; - // Resolve each socket's owning container id from its cgroup (sets the - // record's container_id / container_runtime). Set via -resolveContainerId - // flag or CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it - // and run --cgroupns=host in a container). - bool resolve_container_id = 183 [ - (buf.validate.field).required = false - ]; + // ---- network knobs for xtcp2's own listeners (150-159) ------------------- // Outgoing IPv4 TTL for xtcp2's own TCP listeners (Prometheus + gRPC). // 0 = kernel default. A low value (e.g. 3) keeps replies from travelling // far if the host is unexpectedly internet-exposed — the per-listener // analogue of the host nftables TTL clamp. Set via -ipv4Ttl / IPV4_TTL. // (cf. prometheus/exporter-toolkit#396.) - uint32 ipv4_ttl = 184 [ + uint32 ipv4_ttl = 150 [ (buf.validate.field).required = false, (buf.validate.field).uint32 = { lte: 255 @@ -681,214 +800,145 @@ message XtcpConfig { // Outgoing IPv6 unicast hop limit for xtcp2's own TCP listeners. 0 = kernel // default. Same intent as ipv4_ttl. Set via -ipv6HopLimit / IPV6_HOP_LIMIT. - uint32 ipv6_hop_limit = 185 [ + uint32 ipv6_hop_limit = 151 [ (buf.validate.field).required = false, (buf.validate.field).uint32 = { lte: 255 }]; + // ---- gRPC (160-169) ------------------------------------------------------ + // GRPC listening port - uint32 grpc_port = 190 [ + uint32 grpc_port = 160 [ (buf.validate.field).required = true, (buf.validate.field).uint32 = { gte: 1, lte: 65535 }]; - EnabledDeserializers enabled_deserializers = 200 [ + // ---- profiling (170-179) ------------------------------------------------- + + // Pyroscope continuous-profiling server URL (e.g. + // http://127.0.0.1:4040). When set, the daemon streams CPU, + // memory, goroutine, mutex, and block profiles to that endpoint. + // Empty disables the agent — no overhead in production runs that + // don't need it. Operators bring up a Pyroscope OSS server (or + // Grafana Cloud Pyroscope) and point xtcp2 at it for live profile + // data without restarts. + string pyroscope_url = 170 [ (buf.validate.field).required = false ]; - // When true, route netlink reads and raw-socket destination writes - // through an io_uring ring per Netlinker. Requires Linux 6.1+. - // Library-backed destinations (kafka, nsq, nats, valkey) ignore this - // flag — they continue to use their own client sockets unchanged. - bool io_uring = 210 [ + // Application name registered with the Pyroscope server (the + // "application" facet in the Pyroscope UI). Empty → "xtcp2". + // Set per fleet/role for multi-host environments + // (e.g. "xtcp2.prod.iad", "xtcp2.staging.fra"). + string pyroscope_app_name = 171 [ (buf.validate.field).required = false ]; - // Number of recvmsg SQEs kept in flight per Netlinker ring. Higher - // values reduce io_uring_enter syscalls per dump cycle on hosts with - // many sockets, at the cost of more pinned buffers from packet pool. - // Ignored unless io_uring=true. Default 64. - uint32 io_uring_recv_batch_size = 211 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - gte: 1, - lte: 4096 - }]; - - // Maximum CQEs reaped per PeekBatchCQE call. Larger batches amortise - // userland loop overhead but increase scheduling latency for the - // netlinker goroutine. Ignored unless io_uring=true. Default 128. - uint32 io_uring_cqe_batch_size = 212 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - gte: 1, - lte: 4096 - }]; - - // Comma-separated subset of XtcpFlatRecord json field names selecting - // which columns the csv/tsv marshallers emit (e.g. - // "hostname,inetDiagMsgSocketSourcePort,inetDiagMsgState,tcpInfoRtt"). - // Empty = all fields. Ignored by non-tabular marshallers. - string csv_columns = 220 [ + // CPU profile sampling rate in Hz. Default 100. The Pyroscope + // agent uses this to call runtime.SetCPUProfileRate at startup. + uint32 pyroscope_sample_hz = 172 [ (buf.validate.field).required = false ]; - // Fleet jitter & upload backoff (thundering-herd avoidance). See - // docs/design-jitter-and-backoff.md. All jitter is disabled by setting - // the relevant *_jitter_pct to 0, restoring deterministic behavior. - - // Maximum poll-schedule jitter as a percent of poll_frequency, applied to - // both the startup delay before the first poll and each subsequent tick. - // 0 disables (immediate first poll, fixed interval). Default 20. - uint32 poll_jitter_pct = 221 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - lte: 100 - }]; - - // s3parquet staleness ceiling: force-flush the in-memory Parquet object - // after this long even if it hasn't reached the byte cap, bounding upload - // latency for low-volume hosts. 0 = derive as max(poll_frequency, 30m). - google.protobuf.Duration s3_flush_interval = 222 [ - (buf.validate.field).required = false, - (buf.validate.field).duration = { - gte: { seconds: 0 } - }]; - - // Maximum jitter as a percent of s3_flush_interval, applied to the first - // timed flush and each interval so the fleet doesn't ceiling-flush in - // lockstep. 0 disables. Default 20. - uint32 s3_flush_jitter_pct = 223 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - lte: 100 - }]; - - // Per-object downward jitter as a percent of the s3parquet byte cap: each - // object finalizes at threshold*(1 - rand[0,pct/100]), de-syncing the - // size-cap upload path even under uniform load. Downward-only, so an - // object never exceeds the in-memory byte bound. 0 disables. Default 20. - uint32 s3_flush_threshold_jitter_pct = 224 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - lte: 100 - }]; - - // Maximum S3 upload attempts (original + retries) before dropping the - // object. Retries use full-jitter exponential backoff. Default 10. - uint32 s3_upload_max_attempts = 225 [ - (buf.validate.field).required = false, - (buf.validate.field).uint32 = { - gte: 1, - lte: 100 - }]; - - // Cap on a single upload retry's backoff window (full jitter draws in - // [0, window], window grows exponentially up to this cap). 0 = derive as - // clamp(poll_frequency/10, 1s, 1h). - google.protobuf.Duration s3_upload_backoff_cap = 226 [ - (buf.validate.field).required = false, - (buf.validate.field).duration = { - gte: { seconds: 0 } - }]; - - // Period of the background namespace-reconcile ticker (Method B /proc scan - // that converges the tracked namespace set). With reconcile_before_poll the - // Poller reconciles every cycle and is the real discovery mechanism, so this - // background pass is an occasional safety-net expected to find nothing - // (mapReconciler dels/stores stay 0) — the default is deliberately long (6h) - // so operators can confirm from the counters that it is redundant. It still - // matters when the poller is idle or disabled. 0 disables the background - // ticker entirely (the startup reconcile still runs once). - google.protobuf.Duration reconcile_frequency = 227 [ - (buf.validate.field).required = false, - (buf.validate.field).duration = { - gte: { seconds: 0 } - }]; - - // Run a namespace reconcile immediately before each poll cycle, so a - // namespace that appeared since the last cycle is entered and gets a socket - // within ~1 poll interval instead of waiting for the background ticker. Ties - // discovery cadence to poll cadence; the /proc scan is zero-allocation and - // mutex-serialized with the background reconciler. Default true. - bool reconcile_before_poll = 228; + // Profile upload interval (seconds between batched profile + // pushes). Default 15 s. + uint32 pyroscope_upload_interval_sec = 173 [ + (buf.validate.field).required = false + ]; - // ---- best-effort metadata enrichment (230s) ------------------------------ + // ---- best-effort metadata enrichment (200-249) --------------------------- // Each enricher is independent and non-fatal: when enabled but its source - // (a daemon socket, sysfs) is unavailable, xtcp2 logs, bumps a Prometheus - // counter, and continues with the relevant record columns left empty. + // (a daemon socket, sysfs, a feed file) is unavailable, xtcp2 logs, bumps a + // Prometheus counter, and continues with the relevant record columns left + // empty. One sub-block per enricher. + + // -- container (200-209) + // Resolve each socket's owning container id from its cgroup v2 id + // (inet_diag_cgroup_id, record field 2003) — sets the record's + // container_id / container_runtime. Set via -resolveContainerId flag or + // CONTAINER_ID_RESOLVE env. Needs /sys/fs/cgroup readable (mount it and run + // --cgroupns=host in a container). + bool resolve_container_id = 200 [ + (buf.validate.field).required = false + ]; // Enrich container/netns labels (container_id/name/image/runtime, netns name) // by joining the socket's owning netns inode against the Docker Engine API // index over docker_socket_path. Default false. - bool enrich_container_enable = 230; + bool enrich_container_enable = 201; // Docker Engine API unix socket. Default "/run/docker.sock". - string docker_socket_path = 231 [ + string docker_socket_path = 202 [ (buf.validate.field).string = { max_len: 255 }]; + // -- lldp (210-219) // Enrich per-uplink LLDP neighbor labels by reading the lldpd control socket // (lldpd_socket_path) once at startup. Default false. - bool enrich_lldp_enable = 232; + bool enrich_lldp_enable = 210; // lldpd control socket. Default "/run/lldpd.socket". - string lldpd_socket_path = 233 [ + string lldpd_socket_path = 211 [ (buf.validate.field).string = { max_len: 255 }]; // Optional lldpd version hint ("1.0.13"/"1.0.18") selecting the struct-layout // descriptor for the wire parser. Empty = auto-detect. Default "". - string lldpd_version_hint = 234 [ + string lldpd_version_hint = 212 [ (buf.validate.field).string = { max_len: 16 }]; + // -- nic (220-229) // Enrich per-uplink NIC labels (driver/model/pci/speed/firmware) from sysfs + // the ethtool ioctl once at startup. Default false. - bool enrich_nic_enable = 235; + bool enrich_nic_enable = 220; // Number of host uplink slots to populate (dual-homed hosts = 2). Default 2. - uint32 uplink_count = 236 [ + uint32 uplink_count = 221 [ (buf.validate.field).uint32 = { lte: 2 }]; // Explicit uplink interface names, slot order. Empty = auto-detect from the // default IPv4/IPv6 routes. - repeated string uplink_interfaces = 237 [ + repeated string uplink_interfaces = 222 [ (buf.validate.field).repeated = { max_items: 2 }]; - // Populate nsid (field 32) best-effort via RTM_GETNSID. Usually 0 for + // -- nsid (230-239) + // Populate nsid (record field 32) best-effort via RTM_GETNSID. Usually 0 for // Docker/containerd namespaces. Default false. - bool populate_nsid = 238; + bool populate_nsid = 230; - // Enrich the destination IP's ASN (field 1011) and network owner (field - // 1018) by longest-prefix-matching it against the ipfeed-collector Parquet + // -- asn (240-244) + // Enrich the destination IP's ASN (record field 320) and network owner + // (322) by longest-prefix-matching it against the ipfeed-collector Parquet // artifact (loaded into an in-process trie by pkg/ipasn). Non-fatal: when // enabled but asn_db_path is missing/unreadable, xtcp2 logs, bumps a counter, // and leaves both columns empty. Default false. - bool enrich_asn_enable = 239; + bool enrich_asn_enable = 240; // Path to the ipfeed-collector Parquet artifact (prefix -> {asn, // network_owner}). Default "". - string asn_db_path = 240 [ + string asn_db_path = 241 [ (buf.validate.field).string = { max_len: 255 }]; // How often to reload asn_db_path in the background so a refreshed artifact // is picked up without a restart. 0 = load once at startup, never reload. - google.protobuf.Duration asn_refresh_interval = 241; - - // Classify the destination IP's locality (field 1019) — self / - // connected-subnet / remote — from each monitored network namespace's local - // addresses + routing table, discovered via rtnetlink (pkg/localnet). Runs - // BEFORE the ASN lookup, so self/local-subnet destinations skip it. Non-fatal: - // a per-namespace discovery failure just leaves that namespace's sockets - // unclassified. Default false. - bool enrich_locality_enable = 242; + google.protobuf.Duration asn_refresh_interval = 242; + + // -- locality (245-249) + // Classify the destination IP's locality (record field 310) — self / + // local-subnet / remote — from each monitored network namespace's local + // addresses + routing table, discovered via rtnetlink (pkg/localnet). Also + // yields the egress interface (311/312) and the bound-interface name (300). + // Runs BEFORE the ASN lookup, so self/local-subnet destinations skip it. + // Non-fatal: a per-namespace discovery failure just leaves that namespace's + // sockets unclassified (and is retried with backoff). Default false. + bool enrich_locality_enable = 245; // How often to re-discover local addresses/routes per namespace so runtime // changes (interfaces up/down, routes added) are picked up. Newly-appeared // namespaces are always snapshotted on the next reconcile regardless. 0 = - // discover once per namespace, never refresh. - google.protobuf.Duration locality_refresh_interval = 243; + // discover once per namespace, never refresh. Daemon default 60s. + google.protobuf.Duration locality_refresh_interval = 246; }; message EnabledDeserializers { @@ -946,4 +996,4 @@ message EnabledDeserializers { // // INET_DIAG_SOCKOPT 22 // bool inet_diag_sockopt = 22; -// }; \ No newline at end of file +// }; diff --git a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto index 1b23825..e21dea2 100644 --- a/proto/xtcp_flat_record/v1/xtcp_flat_record.proto +++ b/proto/xtcp_flat_record/v1/xtcp_flat_record.proto @@ -1,20 +1,52 @@ // // xTCP - eXport TCP Inet Diagnostic messages // -// These are all the structs relating to the TCP diagnotic module in the kernel +// XtcpFlatRecord is one flat row per socket: daemon metadata, daemon-computed +// enrichment, and the raw kernel inet_diag payload (struct inet_diag_msg + every +// INET_DIAG_* extension xtcp requests). Protobuf's smallest scalar is 32 bits, +// so kernel __u8/__u16 members are widened to uint32; the trailing comment on +// every payload field records the kernel member and its C type. // -// Please note that protobufs smallest size is 32 bits, so we actually expand uint8/16 to uint32s. -// In the protos below, I've commented which ones are uint8/16 +// Kernel source of truth (Linux 7.2-rc, include/uapi/linux/): +// inet_diag.h struct inet_diag_msg, inet_diag_sockid, inet_diag_meminfo, +// tcpvegas_info, tcp_dctcp_info, tcp_bbr_info, inet_diag_sockopt, +// enum INET_DIAG_* (extension attribute ids) +// tcp.h struct tcp_info +// sock_diag.h enum SK_MEMINFO_* +// net/ipv4/inet_diag.c inet_sk_diag_fill / inet_diag_msg_attrs_fill (what +// each nla_put_* actually carries) // -// There are links to the kernel source showing where the struct came from. +// --------------------------------------------------------------------------- +// FIELD-NUMBER ALLOCATION POLICY (v2, 2026-09) +// --------------------------------------------------------------------------- +// 1-299 metadata daemon identity, time, namespace, container, labels, +// bookkeeping, per-uplink host topology (one block each) +// 300-399 enrichment daemon-COMPUTED fields (NOT read from the kernel): +// 300-309 socket-side, 310-349 destination-side, +// 350-389 source-side (future), 390-399 spare +// 400-999 spare unallocated; open a new metadata/enrichment block here +// 1000+ payload raw kernel inet_diag data, ONE hundred-block per kernel +// struct / INET_DIAG_* extension (1000 inet_diag_msg, +// 1100 meminfo, 1200 tcp_info, 1300 cong, 1400 tos/tclass, +// 1500 skmeminfo, 1600 shutdown, 1700 vegas, 1800 dctcp, +// 1900 bbr, 2000 class_id/sockopt/cgroup_id; next free +// block = 2100) +// Wire cost: tags 1-15 = 1 byte, 16-2047 = 2 bytes, 2048+ = 3 bytes. Every field +// here is <= 2047. Fill free slots inside an existing block before opening one +// above 2047. +// Naming: payload fields are _ using the kernel's +// exact spelling (tcp_info_rttvar, not rtt_var). Attributes with no struct take +// the lowercased INET_DIAG_* name (inet_diag_tos). The six inet_diag_msg_socket_* +// sockid fields keep their descriptive names (heavily used downstream). +// Evolution: never reuse a number or a name (add both to `reserved`); any rename +// or renumber is a new record epoch -> bump XtcpFlatRecordSchemaVersion +// (pkg/xtcp/schema_version.go) and add the matching ClickHouse _vN table + MV +// (build/containers/clickhouse/initdb.d/sql/). Adding a field in a free slot is +// NOT an epoch bump. ClickHouse maps columns by field NAME; Parquet by NAME; +// the csv/tsv marshallers by DECLARATION ORDER; gRPC clients are built from +// gen/go in this repo. // // Build this using buf build ( https://buf.build/ ), see the buf config in the root folder - -// Little reminder on compiling -// https://developers.google.com/protocol-buffers/docs/gotutorial -// go install google.golang.org/protobuf/cmd/protoc-gen-go@latest -// protoc --go_out=paths=source_relative:. xtcppb.proto - // https://protobuf.dev/programming-guides/encoding/#structure syntax = "proto3"; @@ -22,18 +54,11 @@ syntax = "proto3"; package xtcp_flat_record.v1; // https://developers.google.com/protocol-buffers/docs/reference/go-generated -// option go_package = "github.com/randomizedcoder/xtcp2/pkg/xtcppb"; -// option go_package = "github.com/randomizedcoder/xtcp"; option go_package = "./gen/go/xtcp_flat_record"; // https://github.com/bufbuild/protovalidate -// https://buf.build/bufbuild/protovalidate/docs/main:buf.validate -// https://github.com/bufbuild/protovalidate/tree/main/examples -// https://buf.build/docs/lint/rules/?h=protovalidate#protovalidate // import "buf/validate/validate.proto"; -// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information - // Envelope is the protobufList wrapper to allow for batch inserts into Clickhouse // https://clickhouse.com/docs/en/interfaces/formats#protobuflist message Envelope { @@ -41,18 +66,39 @@ message Envelope { repeated XtcpFlatRecord row = 10; }; -// Field-number layout (reorganised 2026-08 while the record had few consumers): -// metadata ... 1-999 (identity + per-uplink network topology) -// payload ... 1000+ (kernel inet_diag subsystems, one hundred-block each) -// ClickHouse's Protobuf format maps columns by field NAME and Parquet uses its own -// schema, so the wire-tag renumber does not break ingestion or historical Parquet. +// xtcp_flat_record is the record type exported by xtcp with ALL the inet_diag information message XtcpFlatRecord { + // Retired numbers/names. NEVER reuse. + // 301/302 v1 egress ifindex/ifname -> 311/312 (v2 regroup by subject) + // 1011/1012/1018/1019 v0 daemon-computed dest asn/next-hop/owner/locality + // -> 320/321/322/310 (moved out of the raw-kernel block) + // 2103 c_group -> inet_diag_cgroup_id 2003 (tidied into the 2000 block) + reserved 301, 302, 1011, 1012, 1018, 1019, 2103; + reserved "inet_diag_msg_socket_dest_asn", "inet_diag_msg_socket_next_hop_asn", + "inet_diag_msg_socket_dest_network_owner", "inet_diag_msg_socket_dest_locality", + "enrich_socket_next_hop_asn", + // v1 -> v2 kernel-spelling renames (same numbers, new names) + "tcp_info_send_scale", "tcp_info_rcv_scale", "tcp_info_fast_open_client_failed", + "tcp_info_rtt_var", "tcp_info_adv_mss", "tcp_info_not_sent_bytes", + "sk_mem_info_rcv_buf", "sk_mem_info_snd_buf", + "vegas_info_rtt_cnt", "vegas_info_min_rtt", + // v1 -> v2 struct-less attribute renames + "congestion_algorithm_string", "congestion_algorithm_enum", + "type_of_service", "traffic_class", "shutdown_state", + "class_id", "sock_opt", "c_group"; + + // ==== metadata (1-299) ===================================================== + // Free: 3-9, 11-19, 22-29, 33-39, 44-49, 52-59, 63-99, 108-119, 125-199, + // 208-219, 225-299. Uplink slots are fixed at two (100s, 200s); a third slot + // would take 250-274, NOT 300 (that is the enrichment block). + // ---- metadata: record format provenance (1-2) ---------------------------- // Record format epoch. Stamped unconditionally into every record so consumers // can route records to per-version tables and migrate/aggregate across them. - // 0 = pre-versioning daemons (this field absent on the wire → proto3 zero - // default), which acts as the "legacy" bucket. Bump the daemon-side constant - // (XtcpFlatRecordSchemaVersion) whenever the format changes meaningfully. + // 0 = pre-versioning daemons (this field absent on the wire -> proto3 zero + // default), which acts as the "legacy" bucket. 1 = 2026-08/09 layout. + // 2 = this layout (kernel-spelled payload names, enrichment regroup). Bump the + // daemon-side constant (XtcpFlatRecordSchemaVersion) on any rename/renumber. uint32 schema_version = 1; // Daemon build provenance (git commit / build date / version, from -ldflags). @@ -61,7 +107,7 @@ message XtcpFlatRecord { string daemon_version = 2; // ---- metadata: time (10) ------------------------------------------------- - int64 timestamp_ns = 10; + int64 timestamp_ns = 10; // time.Now().UnixNano() at record build // ---- metadata: host identity (20s) --------------------------------------- string hostname = 20; @@ -122,7 +168,8 @@ message XtcpFlatRecord { // Static per boot; captured once at startup (best-effort). Hosts are // dual-homed, so there are two fixed uplink slots. All values repeat on every // record and dictionary-compress to ~nothing. NIC info: sysfs + ethtool - // ioctl. LLDP: lldpd control socket (/run/lldpd.socket). + // ioctl (100-107, free 108-119). LLDP: lldpd control socket + // (/run/lldpd.socket) (120-124, free 125-199). string uplink1_ifname = 100; string uplink1_nic_driver = 101; string uplink1_nic_model = 102; @@ -138,6 +185,7 @@ message XtcpFlatRecord { string uplink1_lldp_port_descr = 124; // ---- metadata: host network topology, uplink slot 2 (200s) --------------- + // Same layout as slot 1 (NIC 200-207, LLDP 220-224). string uplink2_ifname = 200; string uplink2_nic_driver = 201; string uplink2_nic_model = 202; @@ -152,54 +200,105 @@ message XtcpFlatRecord { string uplink2_lldp_port_id = 223; string uplink2_lldp_port_descr = 224; - // ==== payload: kernel inet_diag subsystems (1000+) ======================== - // inet_diag_msg inet_diag_msg = 1000; - - uint32 inet_diag_msg_family = 1001; // uint8 - uint32 inet_diag_msg_state = 1002; // uint8 - uint32 inet_diag_msg_timer = 1003; // uint8 - uint32 inet_diag_msg_retrans = 1004; // uint8 - - uint32 inet_diag_msg_socket_source_port = 1005; // __be16 - uint32 inet_diag_msg_socket_destination_port = 1006; // __be16 - bytes inet_diag_msg_socket_source = 1007; - bytes inet_diag_msg_socket_destination = 1008; - uint32 inet_diag_msg_socket_interface = 1009; - uint64 inet_diag_msg_socket_cookie = 1010; // [2]uint32 - uint64 inet_diag_msg_socket_dest_asn = 1011; - uint64 inet_diag_msg_socket_next_hop_asn = 1012; - - uint32 inet_diag_msg_expires = 1013; - uint32 inet_diag_msg_rqueue = 1014; - uint32 inet_diag_msg_wqueue = 1015; - uint32 inet_diag_msg_uid = 1016; - uint32 inet_diag_msg_inode = 1017; - - // Destination network owner (e.g. "cloudflare", "aws"), from the IP-range - // feeds ipfeed-collector parses. Populated alongside dest_asn (1011) by the - // opt-in ASN enricher (pkg/ipasn). Empty when enrichment is disabled or the - // destination IP is not in the feed set. - string inet_diag_msg_socket_dest_network_owner = 1018; - + // ==== enrichment: daemon-COMPUTED fields (300-399) ======================== + // These are NOT read from the kernel inet_diag message; xtcp2 computes them + // from side data (rtnetlink address/route/link discovery, the ipfeed ASN + // feeds) during enrichment. All are opt-in and best-effort: an empty/zero + // value means the relevant enricher was disabled or had no answer. + // Grouped by SUBJECT: what the socket itself is bound to (300s), then + // everything we can say about the DESTINATION endpoint (310-349), with + // 350-389 held for a future SOURCE-side mirror (locality/ASN of the local + // address for listeners / inbound flows) and 390-399 spare. + + // ---- enrichment: socket-side (300-309) ----------------------------------- + // Human name of the interface the socket is BOUND to, i.e. the resolved form + // of inet_diag_msg_socket_interface (1009, the kernel idiag_if index) via the + // namespace's RTM_GETLINK dump. Empty when idiag_if is 0 (the common case — + // most sockets are not SO_BINDTODEVICE-bound) or the index is unknown. + string enrich_socket_interface_name = 300; + // 301-309 free (301/302 retired, see reserved). + + // ---- enrichment: destination-side (310-349) ------------------------------ // Destination endpoint locality, classified from the socket's own network // namespace's local addresses + routing table (discovered via rtnetlink, - // see pkg/localnet). Populated by the opt-in locality enricher BEFORE the - // ASN lookup: SELF and LOCAL_SUBNET destinations never reach the ASN feed, - // so dest_asn (1011) / dest_network_owner (1018) stay empty for them. - // UNSPECIFIED when locality enrichment is disabled or the namespace has no - // snapshot yet. + // see pkg/localnet). Computed BEFORE the ASN lookup: SELF and LOCAL_SUBNET + // destinations never reach the ASN feed, so enrich_socket_dest_asn (320) / + // enrich_socket_dest_network_owner (322) stay empty for them. UNSPECIFIED + // when locality enrichment is disabled or the namespace has no snapshot yet. enum Locality { LOCALITY_UNSPECIFIED = 0; LOCALITY_SELF = 1; // one of this host/namespace's own addresses (or loopback) LOCALITY_LOCAL_SUBNET = 2; // on a directly-connected subnet (one L2 hop, no gateway) LOCALITY_REMOTE = 3; // reached via a gateway (falls through to ASN lookup) }; - Locality inet_diag_msg_socket_dest_locality = 1019; - - // might want to put more here - // https://github.com/torvalds/linux/blob/29d9f30d4ce6c7a38745a54a8cddface10013490/include/uapi/linux/inet_diag.h#L133 - // mem_info mem_info = 1100; // INET_DIAG_MEMINFO 1 - + Locality enrich_socket_dest_locality = 310; + + // The EGRESS interface for the destination, derived from the socket's own + // namespace routing table: the Oif of the route the destination longest-prefix + // matches (pkg/localnet). Unlike interface_name (1009/300) this is populated + // even for unbound sockets — it is "which NIC does traffic to this dest leave + // on". ifindex is the raw kernel index; ifname is it resolved via RTM_GETLINK. + // 0 / empty when the locality enricher is disabled or no route matched. + uint32 enrich_socket_dest_egress_ifindex = 311; + string enrich_socket_dest_egress_ifname = 312; + // 313-319 free (destination routing/locality extras). + + // Populated by the opt-in ASN enricher (pkg/ipasn) only for REMOTE + // destinations. 0 / empty when disabled or the destination IP is not in the + // feed set. network_owner is a human name (e.g. "cloudflare", "aws"). + // dest_next_hop_asn is the first-hop transit ASN toward dest; currently + // always 0 (no BGP RIB source yet) — reserved for that feed. + uint64 enrich_socket_dest_asn = 320; + uint64 enrich_socket_dest_next_hop_asn = 321; + string enrich_socket_dest_network_owner = 322; + // 323-349 free (destination identity/ownership extras). + + // ---- enrichment: source-side (350-389) — RESERVED, none defined yet ------ + // Mirror of 310-349 for the LOCAL endpoint (useful for listeners / inbound + // flows): 350 enrich_socket_src_locality, 351/352 ingress ifindex/ifname, + // 360 enrich_socket_src_asn, 362 enrich_socket_src_network_owner, ... + + // ---- enrichment: spare (390-399) ----------------------------------------- + + // ==== payload: raw kernel inet_diag (1000+) ================================ + // Prefix -> kernel struct: + // inet_diag_msg_* struct inet_diag_msg (+ .id struct inet_diag_sockid) inet_diag.h + // mem_info_* struct inet_diag_meminfo INET_DIAG_MEMINFO (1) inet_diag.h + // tcp_info_* struct tcp_info INET_DIAG_INFO (2) tcp.h + // inet_diag_cong* (string attribute) INET_DIAG_CONG (4) inet_diag.c + // inet_diag_tos (__u8 attribute) INET_DIAG_TOS (5) inet_diag.c + // inet_diag_tclass (__u8 attribute) INET_DIAG_TCLASS (6) inet_diag.c + // sk_mem_info_* __u32[SK_MEMINFO_VARS] INET_DIAG_SKMEMINFO(7) sock_diag.h + // inet_diag_shutdown (__u8 attribute) INET_DIAG_SHUTDOWN (8) inet_diag.c + // vegas_info_* struct tcpvegas_info INET_DIAG_VEGASINFO(3) inet_diag.h + // dctcp_info_* struct tcp_dctcp_info INET_DIAG_DCTCPINFO(9) inet_diag.h + // bbr_info_* struct tcp_bbr_info INET_DIAG_BBRINFO (16) inet_diag.h + // inet_diag_class_id (__u32 attribute) INET_DIAG_CLASS_ID (17) inet_diag.c + // inet_diag_sockopt struct inet_diag_sockopt INET_DIAG_SOCKOPT (22) inet_diag.h + // inet_diag_cgroup_id (__u64 attribute) INET_DIAG_CGROUP_ID(21) inet_diag.c + + // ---- payload: struct inet_diag_msg (1000s) -------------------------------- + // The fixed header of every SOCK_DIAG_BY_FAMILY reply (inet_diag.h). + // Free: 1000, 1018-1099 (1011/1012/1018/1019 retired, see reserved). + uint32 inet_diag_msg_family = 1001; // struct inet_diag_msg.idiag_family (__u8) AF_INET/AF_INET6 + uint32 inet_diag_msg_state = 1002; // struct inet_diag_msg.idiag_state (__u8) TCP_ESTABLISHED..TCP_NEW_SYN_RECV + uint32 inet_diag_msg_timer = 1003; // struct inet_diag_msg.idiag_timer (__u8) 0 none,1 retransmit,2 keepalive,3 timewait,4 zero-window probe + uint32 inet_diag_msg_retrans = 1004; // struct inet_diag_msg.idiag_retrans (__u8) + + uint32 inet_diag_msg_socket_source_port = 1005; // struct inet_diag_msg.id.idiag_sport (__be16) host order here + uint32 inet_diag_msg_socket_destination_port = 1006; // struct inet_diag_msg.id.idiag_dport (__be16) host order here + bytes inet_diag_msg_socket_source = 1007; // struct inet_diag_msg.id.idiag_src (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + bytes inet_diag_msg_socket_destination = 1008; // struct inet_diag_msg.id.idiag_dst (__be32[4]) always the raw 16 bytes; v4 in the first 4 (see family 1010), v6 all 16 + uint32 inet_diag_msg_socket_interface = 1009; // struct inet_diag_msg.id.idiag_if (__u32) bound ifindex, 0 unbound (name: 300) + uint64 inet_diag_msg_socket_cookie = 1010; // struct inet_diag_msg.id.idiag_cookie (__u32[2]) packed lo|hi<<32 + + uint32 inet_diag_msg_expires = 1013; // struct inet_diag_msg.idiag_expires (__u32) ms until idiag_timer fires + uint32 inet_diag_msg_rqueue = 1014; // struct inet_diag_msg.idiag_rqueue (__u32) + uint32 inet_diag_msg_wqueue = 1015; // struct inet_diag_msg.idiag_wqueue (__u32) + uint32 inet_diag_msg_uid = 1016; // struct inet_diag_msg.idiag_uid (__u32) + uint32 inet_diag_msg_inode = 1017; // struct inet_diag_msg.idiag_inode (__u32) + + // ---- payload: struct inet_diag_meminfo, INET_DIAG_MEMINFO 1 (1100s) ------- // DEPRECATED: mem_info duplicates sk_mem_info value-for-value and is off by // default (the daemon no longer requests INET_DIAG_MEMINFO from the kernel), // so these ship as 0 on current records. The same values live in sk_mem_info: @@ -209,102 +308,119 @@ message XtcpFlatRecord { // mem_info_tmem == sk_mem_info_wmem_alloc (1503) // Field numbers retained (never reused); enable with `-deserializers all`. // (Not marked `[deprecated = true]` so the still-supported opt-in decode path - // and tests don't trip staticcheck SA1019.) - uint32 mem_info_rmem = 1101; - uint32 mem_info_wmem = 1102; - uint32 mem_info_fmem = 1103; - uint32 mem_info_tmem = 1104; - - //tcp_info tcp_info = 1200; // INET_DIAG_INFO 2 - - uint32 tcp_info_state = 1201; // uint8 - uint32 tcp_info_ca_state = 1202; // uint8 - uint32 tcp_info_retransmits = 1203; // uint8 - uint32 tcp_info_probes = 1204; // uint8 - uint32 tcp_info_backoff = 1205; // uint8 - uint32 tcp_info_options = 1206; // uint8 -// __u8 _snd_wscale : 4, _rcv_wscale : 4; -// __u8 _delivery_rate_app_limited:1, _fastopen_client_fail:2; - uint32 tcp_info_send_scale = 1207; // uint4 - uint32 tcp_info_rcv_scale = 1208; // uint4 - uint32 tcp_info_delivery_rate_app_limited = 1209; // uint8 - uint32 tcp_info_fast_open_client_failed = 1210; // uint8 - - uint32 tcp_info_rto = 1215; - uint32 tcp_info_ato = 1216; - uint32 tcp_info_snd_mss = 1217; - uint32 tcp_info_rcv_mss = 1218; - - uint32 tcp_info_unacked = 1219; - uint32 tcp_info_sacked = 1220; - uint32 tcp_info_lost = 1221; - uint32 tcp_info_retrans = 1222; - uint32 tcp_info_fackets = 1223; + // and tests don't trip staticcheck SA1019.) Free: 1100, 1105-1199. + uint32 mem_info_rmem = 1101; // struct inet_diag_meminfo.idiag_rmem (__u32) + uint32 mem_info_wmem = 1102; // struct inet_diag_meminfo.idiag_wmem (__u32) + uint32 mem_info_fmem = 1103; // struct inet_diag_meminfo.idiag_fmem (__u32) + uint32 mem_info_tmem = 1104; // struct inet_diag_meminfo.idiag_tmem (__u32) + + // ---- payload: struct tcp_info, INET_DIAG_INFO 2 (1200s) ------------------- + // Declared in struct order (tcp.h). The kernel appends members over time and + // DeserializeTCPInfo (pkg/xtcpnl) accepts every historical struct size, so + // members newer than the running kernel decode as 0. + // Free: 1200, 1211-1214, 1277-1299. 1266-1276 are PRE-ASSIGNED (see below). + uint32 tcp_info_state = 1201; // struct tcp_info.tcpi_state (__u8) + uint32 tcp_info_ca_state = 1202; // struct tcp_info.tcpi_ca_state (__u8) TCP_CA_Open..TCP_CA_Loss + uint32 tcp_info_retransmits = 1203; // struct tcp_info.tcpi_retransmits (__u8) + uint32 tcp_info_probes = 1204; // struct tcp_info.tcpi_probes (__u8) + uint32 tcp_info_backoff = 1205; // struct tcp_info.tcpi_backoff (__u8) + uint32 tcp_info_options = 1206; // struct tcp_info.tcpi_options (__u8) TCPI_OPT_* bitmask + uint32 tcp_info_snd_wscale = 1207; // struct tcp_info.tcpi_snd_wscale (__u8:4) + uint32 tcp_info_rcv_wscale = 1208; // struct tcp_info.tcpi_rcv_wscale (__u8:4) + uint32 tcp_info_delivery_rate_app_limited = 1209; // struct tcp_info.tcpi_delivery_rate_app_limited (__u8:1) + uint32 tcp_info_fastopen_client_fail = 1210; // struct tcp_info.tcpi_fastopen_client_fail (__u8:2) + + uint32 tcp_info_rto = 1215; // struct tcp_info.tcpi_rto (__u32) usec + uint32 tcp_info_ato = 1216; // struct tcp_info.tcpi_ato (__u32) usec + uint32 tcp_info_snd_mss = 1217; // struct tcp_info.tcpi_snd_mss (__u32) + uint32 tcp_info_rcv_mss = 1218; // struct tcp_info.tcpi_rcv_mss (__u32) + + uint32 tcp_info_unacked = 1219; // struct tcp_info.tcpi_unacked (__u32) + uint32 tcp_info_sacked = 1220; // struct tcp_info.tcpi_sacked (__u32) + uint32 tcp_info_lost = 1221; // struct tcp_info.tcpi_lost (__u32) + uint32 tcp_info_retrans = 1222; // struct tcp_info.tcpi_retrans (__u32) + uint32 tcp_info_fackets = 1223; // struct tcp_info.tcpi_fackets (__u32) // Times - uint32 tcp_info_last_data_sent = 1224; - uint32 tcp_info_last_ack_sent = 1225; - uint32 tcp_info_last_data_recv = 1226; - uint32 tcp_info_last_ack_recv = 1227; + uint32 tcp_info_last_data_sent = 1224; // struct tcp_info.tcpi_last_data_sent (__u32) ms ago + uint32 tcp_info_last_ack_sent = 1225; // struct tcp_info.tcpi_last_ack_sent (__u32) "Not remembered, sorry." (always 0) + uint32 tcp_info_last_data_recv = 1226; // struct tcp_info.tcpi_last_data_recv (__u32) ms ago + uint32 tcp_info_last_ack_recv = 1227; // struct tcp_info.tcpi_last_ack_recv (__u32) ms ago // Metrics - uint32 tcp_info_pmtu = 1228; - uint32 tcp_info_rcv_ssthresh = 1229; - uint32 tcp_info_rtt = 1230; - uint32 tcp_info_rtt_var = 1231; - uint32 tcp_info_snd_ssthresh = 1232; - uint32 tcp_info_snd_cwnd = 1233; - uint32 tcp_info_adv_mss = 1234; - uint32 tcp_info_reordering = 1235; - - uint32 tcp_info_rcv_rtt = 1236; - uint32 tcp_info_rcv_space = 1237; - - uint32 tcp_info_total_retrans = 1238; - - uint64 tcp_info_pacing_rate = 1239; - uint64 tcp_info_max_pacing_rate = 1240; - uint64 tcp_info_bytes_acked = 1241; // RFC4898 tcpEStatsAppHCThruOctetsAcked - uint64 tcp_info_bytes_received = 1242; // RFC4898 tcpEStatsAppHCThruOctetsReceived - uint32 tcp_info_segs_out = 1243; // RFC4898 tcpEStatsPerfSegsOut - uint32 tcp_info_segs_in = 1244; // RFC4898 tcpEStatsPerfSegsIn - - uint32 tcp_info_not_sent_bytes = 1245; - uint32 tcp_info_min_rtt = 1246; - uint32 tcp_info_data_segs_in = 1247; // RFC4898 tcpEStatsDataSegsIn - uint32 tcp_info_data_segs_out = 1248; // RFC4898 tcpEStatsDataSegsOut - - uint64 tcp_info_delivery_rate = 1249; - - uint64 tcp_info_busy_time = 1250; // Time (usec) busy sending data - uint64 tcp_info_rwnd_limited = 1251; // Time (usec) limited by receive window - uint64 tcp_info_sndbuf_limited = 1252; // Time (usec) limited by send buffer - - //4.15 kernel tcp_info ends here, 5+ below - - uint32 tcp_info_delivered = 1253; - uint32 tcp_info_delivered_ce = 1254; + uint32 tcp_info_pmtu = 1228; // struct tcp_info.tcpi_pmtu (__u32) + uint32 tcp_info_rcv_ssthresh = 1229; // struct tcp_info.tcpi_rcv_ssthresh (__u32) + uint32 tcp_info_rtt = 1230; // struct tcp_info.tcpi_rtt (__u32) smoothed RTT, usec + uint32 tcp_info_rttvar = 1231; // struct tcp_info.tcpi_rttvar (__u32) RTT variance, usec + uint32 tcp_info_snd_ssthresh = 1232; // struct tcp_info.tcpi_snd_ssthresh (__u32) + uint32 tcp_info_snd_cwnd = 1233; // struct tcp_info.tcpi_snd_cwnd (__u32) segments + uint32 tcp_info_advmss = 1234; // struct tcp_info.tcpi_advmss (__u32) + uint32 tcp_info_reordering = 1235; // struct tcp_info.tcpi_reordering (__u32) + + uint32 tcp_info_rcv_rtt = 1236; // struct tcp_info.tcpi_rcv_rtt (__u32) usec + uint32 tcp_info_rcv_space = 1237; // struct tcp_info.tcpi_rcv_space (__u32) + + uint32 tcp_info_total_retrans = 1238; // struct tcp_info.tcpi_total_retrans (__u32) + + uint64 tcp_info_pacing_rate = 1239; // struct tcp_info.tcpi_pacing_rate (__u64) bytes/sec + uint64 tcp_info_max_pacing_rate = 1240; // struct tcp_info.tcpi_max_pacing_rate (__u64) bytes/sec + uint64 tcp_info_bytes_acked = 1241; // struct tcp_info.tcpi_bytes_acked (__u64) RFC4898 tcpEStatsAppHCThruOctetsAcked + uint64 tcp_info_bytes_received = 1242; // struct tcp_info.tcpi_bytes_received (__u64) RFC4898 tcpEStatsAppHCThruOctetsReceived + uint32 tcp_info_segs_out = 1243; // struct tcp_info.tcpi_segs_out (__u32) RFC4898 tcpEStatsPerfSegsOut + uint32 tcp_info_segs_in = 1244; // struct tcp_info.tcpi_segs_in (__u32) RFC4898 tcpEStatsPerfSegsIn + + uint32 tcp_info_notsent_bytes = 1245; // struct tcp_info.tcpi_notsent_bytes (__u32) + uint32 tcp_info_min_rtt = 1246; // struct tcp_info.tcpi_min_rtt (__u32) usec + uint32 tcp_info_data_segs_in = 1247; // struct tcp_info.tcpi_data_segs_in (__u32) RFC4898 tcpEStatsDataSegsIn + uint32 tcp_info_data_segs_out = 1248; // struct tcp_info.tcpi_data_segs_out (__u32) RFC4898 tcpEStatsDataSegsOut + + uint64 tcp_info_delivery_rate = 1249; // struct tcp_info.tcpi_delivery_rate (__u64) bytes/sec + + uint64 tcp_info_busy_time = 1250; // struct tcp_info.tcpi_busy_time (__u64) usec busy sending data + uint64 tcp_info_rwnd_limited = 1251; // struct tcp_info.tcpi_rwnd_limited (__u64) usec limited by receive window + uint64 tcp_info_sndbuf_limited = 1252; // struct tcp_info.tcpi_sndbuf_limited (__u64) usec limited by send buffer + + // 4.15 kernel tcp_info ends here (192 bytes); 4.19+ below + uint32 tcp_info_delivered = 1253; // struct tcp_info.tcpi_delivered (__u32) + uint32 tcp_info_delivered_ce = 1254; // struct tcp_info.tcpi_delivered_ce (__u32) // https://tools.ietf.org/html/rfc4898 TCP Extended Statistics MIB - uint64 tcp_info_bytes_sent = 1255; // RFC4898 tcpEStatsPerfHCDataOctetsOut - uint64 tcp_info_bytes_retrans = 1256; // RFC4898 tcpEStatsPerfOctetsRetrans - uint32 tcp_info_dsack_dups = 1257; // RFC4898 tcpEStatsStackDSACKDups - uint32 tcp_info_reord_seen = 1258; // reordering events seen - - uint32 tcp_info_rcv_ooopack = 1259; // Out-of-order packets received - - uint32 tcp_info_snd_wnd = 1260; // peer's advertised receive window after scaling (bytes) - uint32 tcp_info_rcv_wnd = 1261; // local advertised receive window after scaling (bytes) - uint32 tcp_info_rehash = 1262; // PLB or timeout triggered rehash attempts - uint32 tcp_info_total_rto = 1263; // Total number of RTO timeouts, including SYN/SYN-ACK and recurring timeouts - uint32 tcp_info_total_rto_recoveries = 1264; // Total number of RTO recoveries, including any unfinished recovery - uint32 tcp_info_total_rto_time = 1265; // Total time spent in RTO recoveries in milliseconds, including any unfinished recovery - - - // Please note it's recommended to use the enum for efficency, but keeping the string - // just in case we need to quickly put a different algorithm in without updating the enum. - // Obviously it's optional, so it low cost. - string congestion_algorithm_string = 1300; // INET_DIAG_CONG 4 + uint64 tcp_info_bytes_sent = 1255; // struct tcp_info.tcpi_bytes_sent (__u64) RFC4898 tcpEStatsPerfHCDataOctetsOut + uint64 tcp_info_bytes_retrans = 1256; // struct tcp_info.tcpi_bytes_retrans (__u64) RFC4898 tcpEStatsPerfOctetsRetrans + uint32 tcp_info_dsack_dups = 1257; // struct tcp_info.tcpi_dsack_dups (__u32) RFC4898 tcpEStatsStackDSACKDups + uint32 tcp_info_reord_seen = 1258; // struct tcp_info.tcpi_reord_seen (__u32) reordering events seen + + uint32 tcp_info_rcv_ooopack = 1259; // struct tcp_info.tcpi_rcv_ooopack (__u32) out-of-order packets received (5.4+) + + uint32 tcp_info_snd_wnd = 1260; // struct tcp_info.tcpi_snd_wnd (__u32) peer's advertised receive window after scaling, bytes + uint32 tcp_info_rcv_wnd = 1261; // struct tcp_info.tcpi_rcv_wnd (__u32) local advertised receive window after scaling, bytes (6.6+) + uint32 tcp_info_rehash = 1262; // struct tcp_info.tcpi_rehash (__u32) PLB or timeout triggered rehash attempts (6.6+) + uint32 tcp_info_total_rto = 1263; // struct tcp_info.tcpi_total_rto (__u16) RTO timeouts incl. SYN/SYN-ACK and recurring (6.10+) + uint32 tcp_info_total_rto_recoveries = 1264; // struct tcp_info.tcpi_total_rto_recoveries (__u16) RTO recoveries incl. any unfinished (6.10+) + uint32 tcp_info_total_rto_time = 1265; // struct tcp_info.tcpi_total_rto_time (__u32) ms in RTO recoveries incl. any unfinished (6.10+) + + // 6.10 kernel tcp_info ends here (248 bytes). PRE-ASSIGNED for the members + // added since (AccECN, Linux 6.13+ / 7.x, tcp.h); declare them when + // DeserializeTCPInfo learns the larger struct size and a matching nlmon + // fixture exists — do NOT hand these numbers to anything else: + // 1266 tcp_info_received_ce struct tcp_info.tcpi_received_ce (__u32) + // 1267 tcp_info_delivered_e1_bytes struct tcp_info.tcpi_delivered_e1_bytes (__u32) + // 1268 tcp_info_delivered_e0_bytes struct tcp_info.tcpi_delivered_e0_bytes (__u32) + // 1269 tcp_info_delivered_ce_bytes struct tcp_info.tcpi_delivered_ce_bytes (__u32) + // 1270 tcp_info_received_e1_bytes struct tcp_info.tcpi_received_e1_bytes (__u32) + // 1271 tcp_info_received_e0_bytes struct tcp_info.tcpi_received_e0_bytes (__u32) + // 1272 tcp_info_received_ce_bytes struct tcp_info.tcpi_received_ce_bytes (__u32) + // 1273 tcp_info_ecn_mode struct tcp_info.tcpi_ecn_mode (__u32:2) + // 1274 tcp_info_accecn_opt_seen struct tcp_info.tcpi_accecn_opt_seen (__u32:2) + // 1275 tcp_info_accecn_fail_mode struct tcp_info.tcpi_accecn_fail_mode (__u32:4) + // 1276 tcp_info_options2 struct tcp_info.tcpi_options2 (__u32:24) + + // ---- payload: INET_DIAG_CONG 4 (1300s) ------------------------------------ + // The kernel emits the congestion-control module name as a NUL-terminated + // string (nla_put_string(skb, INET_DIAG_CONG, ca_ops->name), inet_diag.c). + // It's recommended to use the enum for efficiency, but the string is kept so + // an algorithm the enum does not know yet is still visible. Free: 1302-1399. + string inet_diag_cong = 1300; // INET_DIAG_CONG (4): ca_ops->name (char[TCP_CA_NAME_MAX=16], inet_diag.c) enum CongestionAlgorithm { CONGESTION_ALGORITHM_UNSPECIFIED = 0; CONGESTION_ALGORITHM_CUBIC = 1; @@ -315,51 +431,63 @@ message XtcpFlatRecord { CONGESTION_ALGORITHM_BBR2 = 6; CONGESTION_ALGORITHM_BBR3 = 7; }; - CongestionAlgorithm congestion_algorithm_enum = 1301; // INET_DIAG_CONG 4 - - uint32 type_of_service = 1401; // INET_DIAG_TOS 5 uint8 - uint32 traffic_class = 1402; // INET_DIAG_TCLASS 6 uint8 - - // sk_mem_info sk_mem_info = 1500; // INET_DIAG_SKMEMINFO 7 - - uint32 sk_mem_info_rmem_alloc = 1501; - uint32 sk_mem_info_rcv_buf = 1502; - uint32 sk_mem_info_wmem_alloc = 1503; - uint32 sk_mem_info_snd_buf = 1504; - uint32 sk_mem_info_fwd_alloc = 1505; - uint32 sk_mem_info_wmem_queued = 1506; - uint32 sk_mem_info_optmem = 1507; - uint32 sk_mem_info_backlog = 1508; - uint32 sk_mem_info_drops = 1509; - - uint32 shutdown_state = 1600; // UNIX_DIAG_SHUTDOWN 8uint8 - - // vegas_info vegas_info = 1700; // INET_DIAG_VEGASINFO - - uint32 vegas_info_enabled = 1701; - uint32 vegas_info_rtt_cnt = 1702; - uint32 vegas_info_rtt = 1703; - uint32 vegas_info_min_rtt = 1704; - - // dctcp_info dctcp_info = 1800; // INET_DIAG_DCTCPINFO - - uint32 dctcp_info_enabled = 1801; - uint32 dctcp_info_ce_state = 1802; - uint32 dctcp_info_alpha = 1803; - uint32 dctcp_info_ab_ecn = 1804; - uint32 dctcp_info_ab_tot = 1805; - - // bbr_info bbr_info = 1900; // INET_DIAG_BBRINFO 16 - - uint32 bbr_info_bw_lo = 1901; - uint32 bbr_info_bw_hi = 1902; - uint32 bbr_info_min_rtt = 1903; - uint32 bbr_info_pacing_gain = 1904; - uint32 bbr_info_cwnd_gain = 1905; - - uint32 class_id = 2001; // INET_DIAG_CLASS_ID 17 uint32 - uint32 sock_opt = 2002; // INET_DIAG_SOCKOPT - uint64 c_group = 2103; // INET_DIAG_BC_CGROUP_COND + CongestionAlgorithm inet_diag_cong_enum = 1301; // derived by xtcp from inet_diag_cong (not a kernel field) + + // ---- payload: INET_DIAG_TOS 5 / INET_DIAG_TCLASS 6 (1400s) ---------------- + // Free: 1400, 1403-1499. + uint32 inet_diag_tos = 1401; // INET_DIAG_TOS (5): inet->tos (__u8, inet_diag.c) IPv4 TOS byte + uint32 inet_diag_tclass = 1402; // INET_DIAG_TCLASS (6): np->tclass (__u8, inet_diag.c) IPv6 traffic class + + // ---- payload: SK_MEMINFO_*, INET_DIAG_SKMEMINFO 7 (1500s) ----------------- + // __u32 mem[SK_MEMINFO_VARS] filled by sk_get_meminfo (net/core/sock.c), + // indexed by enum sock_diag.h SK_MEMINFO_*. Free: 1500, 1510-1599. + uint32 sk_mem_info_rmem_alloc = 1501; // SK_MEMINFO_RMEM_ALLOC (__u32, sock_diag.h) sk_rmem_alloc + uint32 sk_mem_info_rcvbuf = 1502; // SK_MEMINFO_RCVBUF (__u32, sock_diag.h) sk_rcvbuf + uint32 sk_mem_info_wmem_alloc = 1503; // SK_MEMINFO_WMEM_ALLOC (__u32, sock_diag.h) sk_wmem_alloc + uint32 sk_mem_info_sndbuf = 1504; // SK_MEMINFO_SNDBUF (__u32, sock_diag.h) sk_sndbuf + uint32 sk_mem_info_fwd_alloc = 1505; // SK_MEMINFO_FWD_ALLOC (__u32, sock_diag.h) sk_forward_alloc + uint32 sk_mem_info_wmem_queued = 1506; // SK_MEMINFO_WMEM_QUEUED (__u32, sock_diag.h) sk_wmem_queued + uint32 sk_mem_info_optmem = 1507; // SK_MEMINFO_OPTMEM (__u32, sock_diag.h) sk_omem_alloc + uint32 sk_mem_info_backlog = 1508; // SK_MEMINFO_BACKLOG (__u32, sock_diag.h) sk_backlog.len + uint32 sk_mem_info_drops = 1509; // SK_MEMINFO_DROPS (__u32, sock_diag.h) sk_drops + + // ---- payload: INET_DIAG_SHUTDOWN 8 (1600s) -------------------------------- + // Free: 1601-1699. + uint32 inet_diag_shutdown = 1600; // INET_DIAG_SHUTDOWN (8): sk->sk_shutdown (__u8, inet_diag.c) RCV_SHUTDOWN=1|SEND_SHUTDOWN=2 + + // ---- payload: struct tcpvegas_info, INET_DIAG_VEGASINFO 3 (1700s) --------- + // Only present when the socket's CC module is vegas (tcp_vegas.c + // tcp_vegas_get_info). Free: 1700, 1705-1799. + uint32 vegas_info_enabled = 1701; // struct tcpvegas_info.tcpv_enabled (__u32) + uint32 vegas_info_rttcnt = 1702; // struct tcpvegas_info.tcpv_rttcnt (__u32) + uint32 vegas_info_rtt = 1703; // struct tcpvegas_info.tcpv_rtt (__u32) usec + uint32 vegas_info_minrtt = 1704; // struct tcpvegas_info.tcpv_minrtt (__u32) usec + + // ---- payload: struct tcp_dctcp_info, INET_DIAG_DCTCPINFO 9 (1800s) -------- + // Only present when the socket's CC module is dctcp (tcp_dctcp.c + // dctcp_get_info); requested via the VEGASINFO bit. Free: 1800, 1806-1899. + uint32 dctcp_info_enabled = 1801; // struct tcp_dctcp_info.dctcp_enabled (__u16) + uint32 dctcp_info_ce_state = 1802; // struct tcp_dctcp_info.dctcp_ce_state (__u16) + uint32 dctcp_info_alpha = 1803; // struct tcp_dctcp_info.dctcp_alpha (__u32) + uint32 dctcp_info_ab_ecn = 1804; // struct tcp_dctcp_info.dctcp_ab_ecn (__u32) + uint32 dctcp_info_ab_tot = 1805; // struct tcp_dctcp_info.dctcp_ab_tot (__u32) + + // ---- payload: struct tcp_bbr_info, INET_DIAG_BBRINFO 16 (1900s) ----------- + // Only present when the socket's CC module is bbr (tcp_bbr.c bbr_get_info); + // requested via the VEGASINFO bit. Free: 1900, 1906-1999. + uint32 bbr_info_bw_lo = 1901; // struct tcp_bbr_info.bbr_bw_lo (__u32) lower 32 bits of bw, bytes/sec + uint32 bbr_info_bw_hi = 1902; // struct tcp_bbr_info.bbr_bw_hi (__u32) upper 32 bits of bw + uint32 bbr_info_min_rtt = 1903; // struct tcp_bbr_info.bbr_min_rtt (__u32) min-filtered RTT, usec + uint32 bbr_info_pacing_gain = 1904; // struct tcp_bbr_info.bbr_pacing_gain (__u32) pacing gain << 8 + uint32 bbr_info_cwnd_gain = 1905; // struct tcp_bbr_info.bbr_cwnd_gain (__u32) cwnd gain << 8 + + // ---- payload: socket classification attributes (2000s) -------------------- + // INET_DIAG_CLASS_ID 17, INET_DIAG_SOCKOPT 22, INET_DIAG_CGROUP_ID 21 — the + // per-socket scalars inet_diag_msg_attrs_fill emits after the CC extensions. + // Free: 2000, 2004-2099. Next free block: 2100. + uint32 inet_diag_class_id = 2001; // INET_DIAG_CLASS_ID (17): classid (__u32, inet_diag.c) net_cls cgroup classid, else sk->sk_priority + uint32 inet_diag_sockopt = 2002; // INET_DIAG_SOCKOPT (22): struct inet_diag_sockopt (2 x __u8 bitfields, inet_diag.h) packed little-endian u16: recverr,is_icsk,freebind,hdrincl,mc_loop,transparent,mc_all,nodefrag | bind_address_no_port,recverr_rfc4884,defer_connect + uint64 inet_diag_cgroup_id = 2003; // INET_DIAG_CGROUP_ID (21): cgroup_id(sock_cgroup_ptr(&sk->sk_cgrp_data)) (__u64, inet_diag.c) cgroup v2 id }; service XTCPFlatRecordService { @@ -377,7 +505,6 @@ message FlatRecordsRequest { message FlatRecordsResponse { XtcpFlatRecord xtcp_flat_record = 1; - // Envelope.XtcpFlatRecord xtcp_flat_record = 1; } message PollFlatRecordsRequest { @@ -386,7 +513,6 @@ message PollFlatRecordsRequest { message PollFlatRecordsResponse { XtcpFlatRecord xtcp_flat_record = 1; - // Envelope.XtcpFlatRecord xtcp_flat_record = 1; } -// end \ No newline at end of file +// end diff --git a/tools/proto-field-audit/kernel_annotation_test.go b/tools/proto-field-audit/kernel_annotation_test.go new file mode 100644 index 0000000..97fc6f2 --- /dev/null +++ b/tools/proto-field-audit/kernel_annotation_test.go @@ -0,0 +1,334 @@ +package main + +import ( + "bytes" + "os" + "path/filepath" + "strings" + "testing" +) + +// kernel_annotation_test.go covers the kernel-source annotation guard: field +// number + trailing-comment extraction, the needs/has predicates, the +// reporting helper, and runAudit end-to-end. Table-driven across the +// positive / negative / boundary / corner matrix. + +// ─────────────────────────────────────────────────────────────────────── +// extractFieldsFromProto: number + trailing comment +// ─────────────────────────────────────────────────────────────────────── + +func TestExtractFieldsFromProto_numberAndComment(t *testing.T) { + t.Parallel() + cases := []struct { + name string + category string + description string + line string // one field line, wrapped in a message + wantNumber int + wantComment string + }{ + { + name: "positive_struct_member_comment", + category: "positive", + description: "tab-indented payload field with a struct-member comment keeps number and comment text", + line: "\tuint32 tcp_info_rttvar = 1231; // struct tcp_info.tcpi_rttvar (__u32) RTT variance", + wantNumber: 1231, + wantComment: "struct tcp_info.tcpi_rttvar (__u32) RTT variance", + }, + { + name: "positive_enum_typed_field", + category: "positive", + description: "custom enum type before the name parses like a scalar", + line: " CongestionAlgorithm inet_diag_cong_enum = 1301; // derived by xtcp from inet_diag_cong", + wantNumber: 1301, + wantComment: "derived by xtcp from inet_diag_cong", + }, + { + name: "negative_no_comment", + category: "negative", + description: "a field without a trailing comment yields an empty comment", + line: " uint32 hostname_len = 7;", + wantNumber: 7, + wantComment: "", + }, + { + name: "boundary_number_zero_like_small", + category: "boundary", + description: "single-byte tag 1 parses", + line: " uint32 schema_version = 1; // routing epoch", + wantNumber: 1, + wantComment: "routing epoch", + }, + { + name: "boundary_max_proto_tag", + category: "boundary", + description: "the protobuf maximum tag 536870911 parses without overflow", + line: " uint32 huge = 536870911; // struct x.y (__u32)", + wantNumber: 536870911, + wantComment: "struct x.y (__u32)", + }, + { + name: "corner_comment_with_extra_slashes", + category: "corner", + description: "only the first // starts the comment; later slashes are content", + line: " uint32 a = 1200; // INET_DIAG_TOS (5): inet->tos // see net/ipv4/inet_diag.c", + wantNumber: 1200, + wantComment: "INET_DIAG_TOS (5): inet->tos // see net/ipv4/inet_diag.c", + }, + { + name: "corner_option_brackets_before_comment", + category: "corner", + description: "buf.validate option brackets between ; and the comment do not break extraction", + line: " uint32 b = 1500 [(buf.validate.field).uint32.lte = 10]; // SK_MEMINFO_RMEM_ALLOC (__u32)", + wantNumber: 1500, + wantComment: "SK_MEMINFO_RMEM_ALLOC (__u32)", + }, + { + name: "corner_comment_without_space_after_slashes", + category: "corner", + description: "//comment glued to the slashes is still trimmed to the text", + line: " uint32 c = 1600; //INET_DIAG_SHUTDOWN (8): sk->sk_shutdown", + wantNumber: 1600, + wantComment: "INET_DIAG_SHUTDOWN (8): sk->sk_shutdown", + }, + } + for _, tc := range cases { + tc := tc + t.Run(tc.category+"/"+tc.name, func(t *testing.T) { + t.Parallel() + src := "message M {\n" + tc.line + "\n}\n" + got := extractFieldsFromProto("t.proto", []byte(src)) + if len(got) != 1 { + t.Fatalf("%s: got %d fields, want 1", tc.description, len(got)) + } + if got[0].number != tc.wantNumber { + t.Errorf("%s: number = %d, want %d", tc.description, got[0].number, tc.wantNumber) + } + if got[0].comment != tc.wantComment { + t.Errorf("%s: comment = %q, want %q", tc.description, got[0].comment, tc.wantComment) + } + }) + } +} + +// ─────────────────────────────────────────────────────────────────────── +// field.needsKernelAnnotation / field.hasKernelAnnotation +// ─────────────────────────────────────────────────────────────────────── + +func TestFieldKernelAnnotation_table(t *testing.T) { + t.Parallel() + cases := []struct { + name string + category string + description string + f field + wantNeeds bool + wantHas bool + wantFinding bool // needs && !has + }{ + { + name: "positive_struct_member", + category: "positive", + description: "struct member form is accepted", + f: field{name: "tcp_info_rttvar", number: 1231, comment: "struct tcp_info.tcpi_rttvar (__u32)"}, + wantNeeds: true, wantHas: true, wantFinding: false, + }, + { + name: "positive_nested_struct_member", + category: "positive", + description: "nested member path (id.idiag_sport) is accepted via the struct prefix", + f: field{name: "inet_diag_msg_socket_source_port", number: 1005, comment: "struct inet_diag_msg.id.idiag_sport (__be16)"}, + wantNeeds: true, wantHas: true, wantFinding: false, + }, + { + name: "positive_inet_diag_attribute", + category: "positive", + description: "struct-less INET_DIAG_* attribute with its id is accepted", + f: field{name: "inet_diag_tos", number: 1401, comment: "INET_DIAG_TOS (5): inet->tos (__u8, inet_diag.c)"}, + wantNeeds: true, wantHas: true, wantFinding: false, + }, + { + name: "positive_sk_meminfo_slot", + category: "positive", + description: "SK_MEMINFO_* array slot is accepted", + f: field{name: "sk_mem_info_rcvbuf", number: 1502, comment: "SK_MEMINFO_RCVBUF (__u32, sock_diag.h)"}, + wantNeeds: true, wantHas: true, wantFinding: false, + }, + { + name: "positive_derived_by_xtcp", + category: "positive", + description: "daemon-derived fields declare themselves as such", + f: field{name: "inet_diag_cong_enum", number: 1301, comment: "derived by xtcp from inet_diag_cong (not a kernel field)"}, + wantNeeds: true, wantHas: true, wantFinding: false, + }, + { + name: "negative_payload_without_comment", + category: "negative", + description: "a payload-range field with no comment is a finding", + f: field{name: "tcp_info_new_thing", number: 1277, comment: ""}, + wantNeeds: true, wantHas: false, wantFinding: true, + }, + { + name: "negative_payload_with_prose_comment", + category: "negative", + description: "a free-text comment that names no kernel source is a finding", + f: field{name: "tcp_info_new_thing", number: 1277, comment: "how many bytes were retransmitted"}, + wantNeeds: true, wantHas: false, wantFinding: true, + }, + { + name: "negative_inet_diag_without_id", + category: "negative", + description: "INET_DIAG_* without the (n) attribute id does not satisfy the convention", + f: field{name: "inet_diag_tos", number: 1401, comment: "INET_DIAG_TOS byte"}, + wantNeeds: true, wantHas: false, wantFinding: true, + }, + { + name: "boundary_tag_999_exempt", + category: "boundary", + description: "the last spare tag below the payload range needs no annotation", + f: field{name: "spare", number: 999, comment: ""}, + wantNeeds: false, wantHas: false, wantFinding: false, + }, + { + name: "boundary_tag_1000_required", + category: "boundary", + description: "the first payload tag requires an annotation", + f: field{name: "inet_diag_msg_family", number: 1000, comment: ""}, + wantNeeds: true, wantHas: false, wantFinding: true, + }, + { + name: "corner_metadata_with_kernel_looking_comment", + category: "corner", + description: "a metadata field may mention a struct without being required to", + f: field{name: "socket_fd", number: 62, comment: "struct netlinker.fd"}, + wantNeeds: false, wantHas: true, wantFinding: false, + }, + { + name: "corner_enrichment_range_exempt", + category: "corner", + description: "daemon-computed 300s enrichment fields are outside the payload range", + f: field{name: "enrich_socket_dest_locality", number: 310, comment: ""}, + wantNeeds: false, wantHas: false, wantFinding: false, + }, + } + for _, tc := range cases { + tc := tc + t.Run(tc.category+"/"+tc.name, func(t *testing.T) { + t.Parallel() + if got := tc.f.needsKernelAnnotation(); got != tc.wantNeeds { + t.Errorf("%s: needsKernelAnnotation = %v, want %v", tc.description, got, tc.wantNeeds) + } + if got := tc.f.hasKernelAnnotation(); got != tc.wantHas { + t.Errorf("%s: hasKernelAnnotation = %v, want %v", tc.description, got, tc.wantHas) + } + var out bytes.Buffer + n := reportUnannotatedPayloadFields([]field{tc.f}, &out) + if (n == 1) != tc.wantFinding { + t.Errorf("%s: reportUnannotatedPayloadFields = %d finding(s), wantFinding=%v; out=%q", + tc.description, n, tc.wantFinding, out.String()) + } + if tc.wantFinding && !strings.Contains(out.String(), tc.f.name) { + t.Errorf("%s: finding does not name the field; out=%q", tc.description, out.String()) + } + }) + } +} + +// ─────────────────────────────────────────────────────────────────────── +// runAudit end-to-end +// ─────────────────────────────────────────────────────────────────────── + +func TestRunAudit_kernelAnnotation(t *testing.T) { + t.Parallel() + const goSrc = ` +package x +type T struct { TcpInfoRttvar uint32; Hostname string } +func use(t T) { _ = t.TcpInfoRttvar; _ = t.Hostname } +` + cases := []struct { + name string + category string + description string + proto string + wantRC int + wantStdout string // substring that must appear; "" = don't check + }{ + { + name: "positive_annotated_payload_is_clean", + category: "positive", + description: "a written, annotated payload field and a metadata field produce no findings", + proto: `syntax = "proto3"; +message Foo { + string hostname = 20; + uint32 tcp_info_rttvar = 1231; // struct tcp_info.tcpi_rttvar (__u32) +} +`, + wantRC: 0, + wantStdout: "no findings", + }, + { + name: "negative_unannotated_payload_fails", + category: "negative", + description: "a written payload field without a kernel comment is reported and fails the audit", + proto: `syntax = "proto3"; +message Foo { + string hostname = 20; + uint32 tcp_info_rttvar = 1231; +} +`, + wantRC: 1, + wantStdout: "lacks a kernel-source trailing comment", + }, + { + name: "boundary_metadata_never_needs_comment", + category: "boundary", + description: "tag 999 without a comment is not a finding", + proto: `syntax = "proto3"; +message Foo { + string hostname = 999; + uint32 tcp_info_rttvar = 1231; // struct tcp_info.tcpi_rttvar (__u32) +} +`, + wantRC: 0, + wantStdout: "no findings", + }, + { + name: "corner_both_findings_counted", + category: "corner", + description: "an unset field and an unannotated field are both reported in one run", + proto: `syntax = "proto3"; +message Foo { + string hostname = 20; + string never_written = 21; + uint32 tcp_info_rttvar = 1231; +} +`, + wantRC: 1, + wantStdout: "never_written", + }, + } + for _, tc := range cases { + tc := tc + t.Run(tc.category+"/"+tc.name, func(t *testing.T) { + t.Parallel() + dir := t.TempDir() + protoDir := filepath.Join(dir, "proto") + goDir := filepath.Join(dir, "go") + for _, d := range []string{protoDir, goDir} { + if err := os.MkdirAll(d, 0o755); err != nil { + t.Fatal(err) + } + } + writeFile(t, protoDir, "x.proto", tc.proto) + writeFile(t, goDir, "x.go", goSrc) + var stdout, stderr bytes.Buffer + rc := runAudit(protoDir, goDir, &stdout, &stderr) + if rc != tc.wantRC { + t.Errorf("%s: rc = %d, want %d; stdout=%q stderr=%q", tc.description, rc, tc.wantRC, stdout.String(), stderr.String()) + } + if tc.wantStdout != "" && !strings.Contains(stdout.String(), tc.wantStdout) { + t.Errorf("%s: stdout missing %q; got %q", tc.description, tc.wantStdout, stdout.String()) + } + }) + } +} diff --git a/tools/proto-field-audit/main.go b/tools/proto-field-audit/main.go index cb247fb..2a94d81 100644 --- a/tools/proto-field-audit/main.go +++ b/tools/proto-field-audit/main.go @@ -8,6 +8,12 @@ // written in Go. (Generated bindings live in gen/go/, so the default scan root // is the module root rather than pkg/.) // +// It also enforces the kernel-source annotation convention of +// xtcp_flat_record.proto: every field whose tag is in the kernel-payload +// range (>= 1000) must carry a trailing comment naming the kernel struct +// member / INET_DIAG_* attribute / SK_MEMINFO_* slot it copies (or say it is +// derived by xtcp). See docs/protobuf-formats.md "Field layout policy". +// // This is the inverse of the existing Rust proto-audit tool in the sibling // xdp2 repo (which audits which kernel structs map to which proto fields). package main @@ -23,11 +29,28 @@ import ( "os" "path/filepath" "regexp" + "strconv" "strings" ) // Match ` = ;` inside `message { ... }`. -var fieldRE = regexp.MustCompile(`^\s*(?:repeated\s+|optional\s+|required\s+)?[\w.<>,]+\s+(\w+)\s*=\s*\d+`) +// Group 1 = field name, group 2 = field number. +var fieldRE = regexp.MustCompile(`^\s*(?:repeated\s+|optional\s+|required\s+)?[\w.<>,]+\s+(\w+)\s*=\s*(\d+)`) + +// kernelAnnotationMinTag is the first field number of the kernel-payload +// range in xtcp_flat_record.proto (metadata 1-299, enrichment 300-399, spare +// 400-999, payload 1000+). Every field at or above it copies a kernel value +// and must say which one in a trailing comment. +const kernelAnnotationMinTag = 1000 + +// kernelAnnotationRE is the shape of the trailing comment every payload field +// must carry, naming the kernel source it copies. Accepted forms: +// +// // struct tcp_info.tcpi_rttvar (__u32) +// // SK_MEMINFO_RCVBUF (__u32, sock_diag.h) +// // INET_DIAG_TOS (5): inet->tos (__u8, inet_diag.c) +// // derived by xtcp from inet_diag_cong (not a kernel field) +var kernelAnnotationRE = regexp.MustCompile(`struct \w+\.\w+|INET_DIAG_\w+ \(\d+\)|SK_MEMINFO_\w+|derived by xtcp`) func main() { os.Exit(runMain(os.Args[1:], os.Stdout, os.Stderr)) @@ -74,17 +97,54 @@ func runAudit(protoRoot, goRoot string, stdout, stderr io.Writer) int { unset++ } } - if unset > 0 { - fmt.Fprintf(stderr, "proto-field-audit: %d unset proto field(s)\n", unset) + unannotated := reportUnannotatedPayloadFields(fields, stdout) + if unset > 0 || unannotated > 0 { + fmt.Fprintf(stderr, "proto-field-audit: %d unset proto field(s), %d payload field(s) without kernel-source comment\n", + unset, unannotated) return 1 } fmt.Fprintln(stdout, "proto-field-audit: no findings") return 0 } +// reportUnannotatedPayloadFields prints one line per field that needs a +// kernel-source annotation (tag >= kernelAnnotationMinTag) but lacks one, +// and returns the count. Fields below the payload range are ignored. +func reportUnannotatedPayloadFields(fields []field, stdout io.Writer) int { + n := 0 + for _, f := range fields { + if f.needsKernelAnnotation() && !f.hasKernelAnnotation() { + fmt.Fprintf(stdout, "%s: proto field %q (tag %d) lacks a kernel-source trailing comment "+ + "(want `// struct . ()`, `// INET_DIAG_ (): ...`, `// SK_MEMINFO_ ...` or `// derived by xtcp ...`)\n", + f.where, f.name, f.number) + n++ + } + } + return n +} + type field struct { - name string - where string + name string + number int + comment string // trailing `//` comment on the declaring line, trimmed; "" if none + where string +} + +// needsKernelAnnotation reports whether the field sits in the kernel-payload +// tag range and therefore must name its kernel source. +func (f field) needsKernelAnnotation() bool { return f.number >= kernelAnnotationMinTag } + +// hasKernelAnnotation reports whether the field's trailing comment matches +// one of the accepted kernel-source forms (kernelAnnotationRE). +func (f field) hasKernelAnnotation() bool { return kernelAnnotationRE.MatchString(f.comment) } + +// trailingComment returns the text after the first `//` on a trimmed +// field line, with surrounding whitespace removed; "" when there is none. +func trailingComment(trimmed string) string { + if i := strings.Index(trimmed, "//"); i >= 0 { + return strings.TrimSpace(trimmed[i+2:]) + } + return "" } // updateProtoMessageDepth steps the message-depth state machine for one @@ -131,9 +191,19 @@ func extractFieldsFromProto(path string, contents []byte) []field { continue } if m := fieldRE.FindStringSubmatch(trimmed); m != nil { + number, err := strconv.Atoi(m[2]) + if err != nil { + // \d+ guarantees digits, so this is only reachable on overflow — + // a tag no valid proto carries. Keep the field so its name is + // still audited; 0 is outside every allocated range and is + // flagged by the number checks. + number = 0 + } fields = append(fields, field{ - name: m[1], - where: fmt.Sprintf("%s:%d", path, i+1), + name: m[1], + number: number, + comment: trailingComment(trimmed), + where: fmt.Sprintf("%s:%d", path, i+1), }) } } diff --git a/tools/tcp_client/tcp_client.go b/tools/tcp_client/tcp_client.go index 1bbed52..e973511 100644 --- a/tools/tcp_client/tcp_client.go +++ b/tools/tcp_client/tcp_client.go @@ -11,7 +11,11 @@ import ( "os" "slices" "sync" + "sync/atomic" + "syscall" "time" + + "golang.org/x/sys/unix" ) const ( @@ -21,6 +25,14 @@ const ( connectCst = "0.0.0.0" + // srcaddrCst / ifaceCst are empty by default so the client behaves exactly as + // before: the kernel picks the source address and egress interface by route. + // When set they bind each connection's source, which xtcp2 reads back as the + // socket's local address / bound interface (idiag_if) for interface-name + // enrichment testing. + srcaddrCst = "" + ifaceCst = "" + writeTimeoutCst = 100 * time.Millisecond readTimeoutCst = 100 * time.Millisecond @@ -54,21 +66,71 @@ func runMain(args []string, stderr io.Writer) int { rto := fs.Duration("rto", readTimeoutCst, "read time out") dialr := fs.Int("dialr", dialRetryCst, "dial retries") pads := fs.Int("pads", padSizeCst, "pad size") + srcaddr := fs.String("srcaddr", srcaddrCst, "bind each connection's source IP (net.Dialer.LocalAddr); empty = kernel default") + iface := fs.String("iface", ifaceCst, "bind each connection to this interface via SO_BINDTODEVICE; empty = kernel default") if err := fs.Parse(args); err != nil { return 2 } + d, err := newDialer(*srcaddr, *iface) + if err != nil { + fmt.Fprintln(stderr, err) + return 2 + } + + // dialFailures counts clients that never established a connection. A + // client that does connect only returns on a read/write error, so a + // non-zero count at the end means part of the requested population was + // never created (bad -iface, unreachable peer, …). Exit 1 in that case so + // a systemd Restart=on-failure unit retries instead of sitting "active + // (exited)" with no sockets behind it. + var dialFailures atomic.Int32 var wg sync.WaitGroup for i := 0; i < *count; i++ { wg.Add(1) - go client(&wg, *connect, startPort+i, *sleep, *wto, *rto, *dialr, *pads) + go client(&wg, &dialFailures, d, *connect, startPort+i, *sleep, *wto, *rto, *dialr, *pads) time.Sleep(*startsleep) } wg.Wait() + if n := dialFailures.Load(); n > 0 { + fmt.Fprintf(stderr, "tcp_client: %d of %d clients never connected\n", n, *count) + return 1 + } return 0 } +// newDialer builds the net.Dialer used for every connection, applying the +// optional source-address bind (LocalAddr) and interface bind (SO_BINDTODEVICE). +// Both are empty by default, yielding a zero-value Dialer identical to the +// previous behaviour. A non-empty but unparseable srcaddr is a hard error so a +// misconfigured load container fails loudly rather than silently binding nothing. +func newDialer(srcaddr, iface string) (net.Dialer, error) { + var d net.Dialer + if srcaddr != "" { + ip := net.ParseIP(srcaddr) + if ip == nil { + return net.Dialer{}, fmt.Errorf("invalid -srcaddr %q", srcaddr) + } + d.LocalAddr = &net.TCPAddr{IP: ip} + } + if iface != "" { + name := iface + d.Control = func(_, _ string, c syscall.RawConn) error { + var operr error + if cerr := c.Control(func(fd uintptr) { + operr = unix.SetsockoptString(int(fd), unix.SOL_SOCKET, unix.SO_BINDTODEVICE, name) + }); cerr != nil { + return cerr + } + return operr + } + } + return d, nil +} + func client(wg *sync.WaitGroup, + dialFailures *atomic.Int32, + d net.Dialer, bind string, port int, sleep time.Duration, @@ -83,9 +145,10 @@ func client(wg *sync.WaitGroup, buf := buildMessage(port, pads) reply := make([]byte, readBufferSizeCst) - conn, err := dialWithRetry(bind, port, dialr, dialTimeoutCst) + conn, err := dialWithRetryDialer(d, bind, port, dialr, dialTimeoutCst) if err != nil { log.Printf("dialWithRetry: %v", err) + dialFailures.Add(1) return } @@ -130,6 +193,13 @@ func buildMessage(port, pads int) []byte { // matches the comment, and if attempts <= 0 we report it instead of // pretending we ran a loop. func dialWithRetry(bind string, port, attempts int, baseTimeout time.Duration) (net.Conn, error) { + return dialWithRetryDialer(net.Dialer{}, bind, port, attempts, baseTimeout) +} + +// dialWithRetryDialer is dialWithRetry with a caller-supplied base Dialer (so the +// source-address / interface binds from newDialer are applied). It overrides only +// the per-attempt Timeout, leaving LocalAddr/Control intact across retries. +func dialWithRetryDialer(base net.Dialer, bind string, port, attempts int, baseTimeout time.Duration) (net.Conn, error) { addr := fmt.Sprintf("%s:%d", bind, port) if attempts <= 0 { return nil, fmt.Errorf("dial %s: attempts must be > 0, got %d", addr, attempts) @@ -137,7 +207,8 @@ func dialWithRetry(bind string, port, attempts int, baseTimeout time.Duration) ( timeout := baseTimeout var lastErr error for r := 0; r < attempts; r++ { - dialer := net.Dialer{Timeout: timeout} + dialer := base + dialer.Timeout = timeout dialCtx, cancel := context.WithTimeout(context.Background(), timeout) conn, err := dialer.DialContext(dialCtx, "tcp", addr) cancel() diff --git a/tools/tcp_client/tcp_client_test.go b/tools/tcp_client/tcp_client_test.go index 35394dc..34e1ea6 100644 --- a/tools/tcp_client/tcp_client_test.go +++ b/tools/tcp_client/tcp_client_test.go @@ -6,6 +6,7 @@ import ( "net" "strings" "sync" + "sync/atomic" "testing" "time" ) @@ -223,10 +224,11 @@ func TestClient_dialFailure(t *testing.T) { _ = ln.Close() var wg sync.WaitGroup + var failures atomic.Int32 wg.Add(1) done := make(chan struct{}) go func() { - client(&wg, "127.0.0.1", port, time.Hour, time.Second, time.Second, 2, 4) + client(&wg, &failures, net.Dialer{}, "127.0.0.1", port, time.Hour, time.Second, time.Second, 2, 4) close(done) }() wg.Wait() @@ -235,6 +237,9 @@ func TestClient_dialFailure(t *testing.T) { case <-time.After(2 * time.Second): t.Fatal("client did not return on dial failure") } + if got := failures.Load(); got != 1 { + t.Errorf("dial failures = %d, want 1", got) + } } // client() reaching the read-error branch: dial succeeds, then the server @@ -257,10 +262,11 @@ func TestClient_serverCloses(t *testing.T) { }() var wg sync.WaitGroup + var failures atomic.Int32 wg.Add(1) done := make(chan struct{}) go func() { - client(&wg, "127.0.0.1", port, time.Hour, time.Second, time.Second, 5, 4) + client(&wg, &failures, net.Dialer{}, "127.0.0.1", port, time.Hour, time.Second, time.Second, 5, 4) close(done) }() wg.Wait() @@ -269,11 +275,134 @@ func TestClient_serverCloses(t *testing.T) { case <-time.After(2 * time.Second): t.Fatal("client did not return after server close") } + // The dial succeeded; only the later read failed, so this is not a + // "never connected" client. + if got := failures.Load(); got != 0 { + t.Errorf("dial failures = %d, want 0", got) + } +} + +// TestNewDialer covers the source-address / interface binding wiring: which +// inputs set LocalAddr, which set Control, and which are rejected. Every row +// carries a description and the expected outcome (LocalAddr IP, Control presence, +// or error) across positive, negative, boundary and corner cases. +func TestNewDialer(t *testing.T) { + tests := []struct { + description string + srcaddr string + iface string + wantErr bool + wantLocalIP string // "" = expect nil LocalAddr + wantControl bool + }{ + // positive + {"both empty -> zero dialer (kernel default)", "", "", false, "", false}, + {"valid IPv4 srcaddr sets LocalAddr", "10.0.0.5", "", false, "10.0.0.5", false}, + {"valid IPv6 srcaddr sets LocalAddr", "2001:db8::5", "", false, "2001:db8::5", false}, + {"iface sets a Control hook", "", "dum0", false, "", true}, + // negative + {"invalid srcaddr -> error", "not-an-ip", "", true, "", false}, + {"invalid srcaddr rejected even with valid iface", "999.999.0.1", "dum0", true, "", false}, + // boundary — the unspecified address is a valid IP (binds to any) + {"unspecified IPv4 srcaddr is valid", "0.0.0.0", "", false, "0.0.0.0", false}, + // corner — both set together + {"srcaddr + iface both applied", "10.0.0.5", "dum1", false, "10.0.0.5", true}, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + d, err := newDialer(tc.srcaddr, tc.iface) + if tc.wantErr { + if err == nil { + t.Fatalf("newDialer(%q,%q) err = nil, want error", tc.srcaddr, tc.iface) + } + return + } + if err != nil { + t.Fatalf("newDialer(%q,%q) unexpected err: %v", tc.srcaddr, tc.iface, err) + } + if tc.wantLocalIP == "" { + if d.LocalAddr != nil { + t.Errorf("LocalAddr = %v, want nil", d.LocalAddr) + } + } else { + ta, ok := d.LocalAddr.(*net.TCPAddr) + if !ok || ta.IP.String() != tc.wantLocalIP { + t.Errorf("LocalAddr = %v, want IP %s", d.LocalAddr, tc.wantLocalIP) + } + } + if (d.Control != nil) != tc.wantControl { + t.Errorf("Control set = %v, want %v", d.Control != nil, tc.wantControl) + } + }) + } } -func TestRunMain_invalidFlag(t *testing.T) { - if rc := runMain([]string{"-not-a-flag"}, &strings.Builder{}); rc != 2 { - t.Errorf("rc = %d, want 2", rc) +// TestRunMain covers the exit-code contract of the whole binary: flag / +// dialer construction errors are rc 2, a population that never connected is +// rc 1, and a no-op fan-out is rc 0. The -iface row opens a real socket: the +// SO_BINDTODEVICE setsockopt in the dialer's Control hook fails with ENODEV +// for an interface that does not exist, before any connect() is attempted, +// so the row is deterministic regardless of what listens on startPort. +func TestRunMain(t *testing.T) { + tests := []struct { + description string + args []string + wantRC int + wantStderr string // substring; "" = don't care + }{ + { + description: "bad -srcaddr fails the process rather than silently binding nothing", + args: []string{"-count", "1", "-srcaddr", "nonsense"}, + wantRC: 2, + wantStderr: "invalid -srcaddr", + }, + { + description: "unknown flag is a usage error", + args: []string{"-not-a-flag"}, + wantRC: 2, + wantStderr: "flag provided but not defined", + }, + { + description: "-count 0 is a pure no-op fan-out and exits clean", + args: []string{"-count", "0"}, + wantRC: 0, + }, + { + description: "-iface of a nonexistent device: SO_BINDTODEVICE ENODEV on the real socket, client never connects, rc 1", + args: []string{ + "-count", "1", "-connect", "127.0.0.1", "-iface", "nonexistent0", + "-startsleep", "1ms", "-dialr", "2", "-pads", "4", + }, + wantRC: 1, + wantStderr: "1 of 1 clients never connected", + }, + { + description: "-iface with -count 2: every client fails the same way and the tally reports both", + args: []string{ + "-count", "2", "-connect", "127.0.0.1", "-iface", "nonexistent0", + "-startsleep", "1ms", "-dialr", "1", "-pads", "4", + }, + wantRC: 1, + wantStderr: "2 of 2 clients never connected", + }, + } + for _, tc := range tests { + t.Run(tc.description, func(t *testing.T) { + var stderr strings.Builder + done := make(chan int, 1) + go func() { done <- runMain(tc.args, &stderr) }() + select { + case rc := <-done: + if rc != tc.wantRC { + t.Errorf("rc = %d, want %d (stderr %q)", rc, tc.wantRC, stderr.String()) + } + if tc.wantStderr != "" && !strings.Contains(stderr.String(), tc.wantStderr) { + t.Errorf("stderr = %q, want substring %q", stderr.String(), tc.wantStderr) + } + case <-time.After(5 * time.Second): + t.Fatalf("runMain did not return; a client connected to startPort and is looping") + } + }) } }