rosotacom-dev 2.5.dev34__tar.gz → 2.5.dev36__tar.gz

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev34
+Version: 2.5.dev36
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause
@@ -311,6 +311,25 @@ rosotacom start 1_heartbeat --identity b \
 
 `rosotacom` reads the static session input and creates generated files under `session-instances/<date>/<session>_<timestamp>_<id>/config/`, including per-peer plugin/session specs, topic lists, optional QoS, and optional `domain_bridge.yaml`. Catmux pane output is logged under the same instance in `logs/<peer>/catmux/`.
 
+What else a run leaves under `logs/<peer>/`, and which file to open first when a
+peer looked healthy but did nothing:
+
+| File | Written by | Read it for |
+|---|---|---|
+| `catmux/<NN>-<WINDOW>/<pane>.log` | `catmux_log_setup.sh` (`tmux pipe-pane`) | everything a node printed, including the traceback it died with |
+| `pane_failures.log` | the same script's prompt hook | one line per non-zero pane exit — **the file that answers "is any pane dead?"** |
+| `status/startup_check.json` | `status_overview`, once, after `status_startup_grace_s` and one confirming look a grace later | the verdict: which outbound stages this peer produces and never published, plus the pane failures above |
+| `status/status.{json,txt}` and `status/events.jsonl` | `status_overview`, continuously | live per-stage state and the transit records |
+| `scenario/<component>.log` | `rosotacom start <scenario>` | each scenario application's own output |
+| `launcher.log`, `docker.log` | `rosotacom start` | the exact command, and the container's own stdout where it has one |
+
+A pane whose command exits drops back to a shell prompt and keeps looking alive
+— `docker ps` shows a healthy container and the other panes keep working. That
+is how a control centre ran for two hours on 2026-08-13 with no heartbeat
+publisher, because Cyclone had no free participant index left on the local
+domain and `heartbeat_echo` died two seconds after start. The last two rows of
+that table exist so the next one announces itself.
+
 ### Complete use cases with scenarios
 
 A session intentionally describes only the communication contract. When a use
@@ -577,9 +596,15 @@ The running session writes, under
 - `status.json` — machine-readable snapshot (source of truth) for tools/agents,
   refreshed on a short interval and on every state transition,
 - `status.txt` — a human-rendered table, and
-- `events.jsonl` — state transitions plus per-`(topic, seq)` transit records for
-  wrapped topics (delivered/lost/reordered, section latency, size, inter-arrival,
-  and jitter).
+- `events.jsonl` — state transitions plus per-`(topic, epoch, seq)` transit
+  records for wrapped topics (delivered/lost/reordered, section latency, size,
+  inter-arrival, and jitter). `epoch` counts the restarts of the sending peer's
+  wrapper: sequence numbers start at zero again after one, so it is what keeps
+  the numbering unique over an instance that outlived a restart.
+
+Which of the bandwidth numbers a session publishes answers which question —
+per-stream payload, whole-interface wire traffic, and the overhead ratio
+between them — is in [link bandwidth](docs/link-bandwidth.md).
 
 For fixed-interval network-condition samples alongside the same session, enable
 the [link trace recorder](docs/link-trace.md). It writes

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/README.md

@@ -266,6 +266,25 @@ rosotacom start 1_heartbeat --identity b \
 
 `rosotacom` reads the static session input and creates generated files under `session-instances/<date>/<session>_<timestamp>_<id>/config/`, including per-peer plugin/session specs, topic lists, optional QoS, and optional `domain_bridge.yaml`. Catmux pane output is logged under the same instance in `logs/<peer>/catmux/`.
 
+What else a run leaves under `logs/<peer>/`, and which file to open first when a
+peer looked healthy but did nothing:
+
+| File | Written by | Read it for |
+|---|---|---|
+| `catmux/<NN>-<WINDOW>/<pane>.log` | `catmux_log_setup.sh` (`tmux pipe-pane`) | everything a node printed, including the traceback it died with |
+| `pane_failures.log` | the same script's prompt hook | one line per non-zero pane exit — **the file that answers "is any pane dead?"** |
+| `status/startup_check.json` | `status_overview`, once, after `status_startup_grace_s` and one confirming look a grace later | the verdict: which outbound stages this peer produces and never published, plus the pane failures above |
+| `status/status.{json,txt}` and `status/events.jsonl` | `status_overview`, continuously | live per-stage state and the transit records |
+| `scenario/<component>.log` | `rosotacom start <scenario>` | each scenario application's own output |
+| `launcher.log`, `docker.log` | `rosotacom start` | the exact command, and the container's own stdout where it has one |
+
+A pane whose command exits drops back to a shell prompt and keeps looking alive
+— `docker ps` shows a healthy container and the other panes keep working. That
+is how a control centre ran for two hours on 2026-08-13 with no heartbeat
+publisher, because Cyclone had no free participant index left on the local
+domain and `heartbeat_echo` died two seconds after start. The last two rows of
+that table exist so the next one announces itself.
+
 ### Complete use cases with scenarios
 
 A session intentionally describes only the communication contract. When a use
@@ -532,9 +551,15 @@ The running session writes, under
 - `status.json` — machine-readable snapshot (source of truth) for tools/agents,
   refreshed on a short interval and on every state transition,
 - `status.txt` — a human-rendered table, and
-- `events.jsonl` — state transitions plus per-`(topic, seq)` transit records for
-  wrapped topics (delivered/lost/reordered, section latency, size, inter-arrival,
-  and jitter).
+- `events.jsonl` — state transitions plus per-`(topic, epoch, seq)` transit
+  records for wrapped topics (delivered/lost/reordered, section latency, size,
+  inter-arrival, and jitter). `epoch` counts the restarts of the sending peer's
+  wrapper: sequence numbers start at zero again after one, so it is what keeps
+  the numbering unique over an instance that outlived a restart.
+
+Which of the bandwidth numbers a session publishes answers which question —
+per-stream payload, whole-interface wire traffic, and the overhead ratio
+between them — is in [link bandwidth](docs/link-bandwidth.md).
 
 For fixed-interval network-condition samples alongside the same session, enable
 the [link trace recorder](docs/link-trace.md). It writes

rosotacom_dev-2.5.dev36/docs/link-bandwidth.md

@@ -0,0 +1,73 @@
+# Link bandwidth: what each number means
+
+Three bandwidth numbers exist in a running session, and they answer three
+different questions. Mixing them up is how a link that delivered ~6 Mbit/s was
+reported at ~28 Gbit/s for a whole field run.
+
+| Topic / field | Measured where | Counts | Scope |
+|---|---|---|---|
+| `/topic_monitor/<dir>/<name>[/to_<peer>]/ros_topic_bandwidth_kbps` | subscriber on the local domain | serialized ROS payload of every `/com/<dir>/<name>/…` stage topic | one peer, one direction, application payload only |
+| `/topic_monitor/<dir>/<name>[/to_<peer>]/link_bandwidth_kbps` | `/proc/net/dev` counters of the OTA interface | every byte the kernel moved over that interface | the whole interface, all peers and all protocols on it |
+| `status.json` → `link` | the same counters, plus the overview's own per-stage sizes and rates | both of the above, and their ratio | one peer, both directions |
+
+`kbps` here is **Kibit/s** — bytes × 8 / 1024 / seconds. It has meant that
+since the topic existed; the name is kept so old recordings keep their meaning.
+The factor to Mbit/s is 1.024/1000, i.e. 6000 `kbps` ≈ 6.1 Mbit/s.
+
+## Which one answers "what does the camera cost the link"
+
+Neither `link_bandwidth_kbps` alone. It is an *interface* number: it includes
+DDS discovery, RTPS retransmits, ACKs, IP/UDP headers, and anything else
+sharing the interface. That is what makes it useful — the overhead is exactly
+what a payload sum cannot see — but it is not attributable to one stream.
+
+The attributable number is the per-topic row in `topic_monitor`'s table (or the
+per-stage `mean_size_bytes` × `hz` in `status.json`), and the honest way to
+report the cost of a stream on the link is the pair: payload for the stream,
+plus the session-level `overhead_ratio_out` / `overhead_ratio_in` from
+`status.json`, which is `link / payload` at the OTA boundary. A ratio near 1
+means the wire carries little beyond the payload; well above 1 means
+retransmits, shadow connections, discovery chatter, or QoS that does not fit
+the link. Small messages have a naturally higher ratio, because per-packet
+headers are a larger share of them.
+
+Per-remote-peer wire attribution is **not** available from these counters. On
+the deployments this stack runs on, the OTA interface is a dedicated tunnel
+carrying exactly one peer, so the interface number *is* the peer number. A
+setup that multiplexes peers on one interface needs a per-peer filter (`iftop`
+in the `NET` window, or packet accounting), and the `link` numbers should then
+be read as an upper bound.
+
+## How the interface is found
+
+From `ip_local` — the peer's own OTA address — by `find_interface_for_ip`,
+inside the node. `topic_monitor` and `status_overview` share
+`resolve_link_interface`, so they cannot disagree. An explicit `interface`
+parameter overrides it for a setup an address cannot describe.
+
+**A loopback interface is refused** when `ip_local` is not itself a loopback
+address, because loopback carries this host's own intra-process ROS traffic.
+`topic_monitor` fails to start; `status_overview` disables the `link` block and
+warns. Both are better than the number that made this rule necessary.
+
+### What went wrong before (issue #267)
+
+The interface used to be resolved in the session template:
+
+```yaml
+- interface=$(ip -o addr | awk '/'${ip_local//./\\.}'\/[0-9]+/ {print $2; exit}')
+```
+
+catmux substitutes `${name}` and nothing else — see
+`tests/contract/test_session_template_substitution.py`. `${ip_local//./\\.}` is
+not that form, so it reached the pane literally, bash expanded an unset shell
+variable to the empty string, and the awk program became `/\/[0-9]+/` — "the
+first address line with a prefix length", which is `lo` on every Linux host.
+
+Both peers therefore reported loopback traffic as link bandwidth for the whole
+2026-08-13 field session. On the centre it read ~5–7 Mbit/s and looked
+plausible. On the vehicle, which was also writing a 36 GB `-a` recording over
+the same loopback, it read ~28 Gbit/s — near-constant, and identical in both
+directions, which is the loopback signature (`rx_bytes` and `tx_bytes` are the
+same bytes). `status_overview`, which already resolved the interface in the
+node, reported `tun1` correctly in the same run.

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/docs/rfcs/0003-metric-backbone.md

@@ -46,7 +46,8 @@ It **feeds** the existing verdict layer (unlocks `expect.loss_pct`; sharpens
 Every metric on the wishlist is a projection of one recorded object per message:
 
 ```
-(topic, seq):
+(topic, epoch, seq):
+  epoch       (receiver-derived)  — which run of the sender's wrapper this seq belongs to
   t_wrap      (sender clock)     — OtaStamped.header.stamp
   t_com_in    (receiver clock)   — arrival immediately after bridge_in
   status      — delivered | lost | reordered                        [from seq gap]
@@ -55,6 +56,21 @@ Every metric on the wishlist is a projection of one recorded object per message:
   inter_arrival / jitter         — receiver-local regularity
 ```
 
+**Why `epoch` is part of the key.** `universal_ota_wrapper` counts per topic
+from zero, so a peer that restarts inside an instance replays sequence numbers
+the receiver has already seen. The receiver detects the restart from the
+sequence stream itself (a backward jump larger than any reordering the
+transport can produce — `is_sequence_epoch_reset`) and counts epochs from 0.
+Without it, two things break at once and neither announces itself: live
+accounting calls every arrival after the restart `reordered`, and the offline
+join collapses the second run onto the first. On the 2026-08-13 field instance
+that was 124,572 of 304,876 records misclassified and 123,253 dropped from the
+joined output — 40% of the run, concentrated in the mission window.
+
+Epochs are receiver-local numbering, not an identifier the peers agree on:
+each side counts the restarts it observes on its own inbound stream. That is
+enough for both consumers, because both key within one receiver's records.
+
 The envelope carries only what the cross-host **OTA hop** needs (`t_wrap` +
 `seq`). Local / per-stage latency — including the message's pre-OTA pipeline cost —
 is read uniformly from the `stage_latency` join (mechanism 3), **not** from an
@@ -210,6 +226,11 @@ in-order.
   restamp/latch/drop/throttle/pixel/frame transforms before compression and
   wrapping. Therefore `com_in` sequence gaps exclude intended pre-wrap shaping
   and measure failure after the wrap point.
+- **A restart costs the epoch's head, not the run.** The receiver cannot know
+  how many messages the peer published before DDS discovery matched the reader,
+  so the messages before the first arrival of a new epoch are not counted as
+  lost. In the 2026-08-13 instance that head was 37 to 41 messages per restart.
+  Counting them would report a loss the link never caused.
 - **`θ` drifts.** Re-estimate continuously; fine for short runs, relevant for
   hour-long sessions.
 - **Head-of-line blocking is the real failure mode.** Field data: a heavy message
@@ -275,9 +296,18 @@ PR; the e2e row runs in the single-machine smoke matrix (`just test-e2e-smoke`);
 the cross-host rows are the operator OTA gate.
 
 - [x] **Sequence loss / reorder / burst / epoch reset** — host:
-  `test_status_overview.py::test_sequence_loss_reorder_and_transit_records` and
-  `::test_sequence_zero_starts_new_epoch_after_publisher_restart`. Live: the e2e
+  `test_status_overview.py::test_sequence_loss_reorder_and_transit_records`,
+  `::test_sequence_zero_starts_new_epoch_after_publisher_restart`,
+  `::test_restart_is_recognised_when_seq_zero_never_arrives` (the field shape:
+  the first arrival of a new epoch is seq 37, not 0),
+  `::test_a_small_backward_jump_is_still_reordering` and
+  `::test_transit_records_carry_the_epoch_they_were_counted_in`. Live: the e2e
   row asserts delivered transit records on a running pipeline.
+- [x] **Epoch-keyed offline join** — host:
+  `test_transit.py::test_join_keeps_sequence_numbers_from_different_epochs_apart`,
+  `::test_records_without_an_epoch_are_one_epoch`,
+  `::test_lost_records_are_bounded_within_their_own_epoch` and
+  `::test_nominal_send_period_ignores_the_step_across_a_restart`.
 - [x] **`expect.loss_pct { max, stage? }` evaluation** — host:
   `test_status_eval.py::test_loss_pct_uses_first_sequence_aware_stage`,
   `::test_loss_pct_exceeded_fails`,

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/session-configuration.md

@@ -169,6 +169,15 @@ Per-side config blocks:
 - DDS implementations (`cyclone`, `fastdds`) accept:
   - `config: <template>` — template file under `ws/ota_configs/` (e.g. `fastdds_v1.xml`, `cyclonedds.xml`, `fastdds_easy_mode.xml`). Omit to use the RMW's built-in defaults.
   - `easy_mode_ip: <string>` — only honored by `fastdds_easy_mode.xml`; defaults to the first resolved peer address.
+
+  On the **local** side of a busy machine, set
+  `config: cyclonedds_local_participants.xml`. Cyclone allows 33 participants
+  per domain per host by default, and a control centre running its own
+  application next to the communication peer exceeds that: the processes that
+  start last fail with `Failed to find a free participant index for domain N`
+  and exit. That template raises the limit and changes nothing else — it pins no
+  interface and sets no peer list, because local discovery must keep working.
+  The OTA templates are not usable on the local side for exactly that reason.
 - `zenoh_connect_endpoints` (native, OTA side only; `zenoh` is still accepted as a legacy OTA alias) accepts:
   - `main_peer: <peer_key>` — the peer whose zenoh router listens. Defaults to the first peer declared under `peers:`.
   - `main_port: 7447` — listening port. Default `7447`.

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/src/rosotacom/cli.py

@@ -1083,10 +1083,30 @@ def _mark_interactive_smoke_stopped(instance_dir: Path, target_type: str, target
 
 
 def _write_docker_log(container_name: str, instance: SessionInstance, identity: str) -> None:
+    """Snapshot the peer container's own stdout into ``logs/<peer>/docker.log``.
+
+    In `attach` mode the container is `--rm` and already gone by the time this
+    runs, so `docker logs` answers "No such container". That answer used to be
+    written verbatim, which produced a 75-byte file that reads like the record
+    of the run and says nothing -- it was the whole of `logs/<peer>/` besides
+    `launcher.log` when a field session had to be diagnosed after the fact
+    (#266). The catmux per-pane logs under `catmux/` are the actual record, so
+    say that instead of pretending this file is one.
+    """
     try:
         result = subprocess.run(["docker", "logs", container_name], text=True, capture_output=True, check=False)
     except Exception:
         return
+    if result.returncode != 0:
+        stderr = (result.stderr or "").strip()
+        _append_log(
+            _peer_docker_log(instance, identity),
+            f"[rosotacom] docker logs {container_name}: {stderr or 'unavailable'}\n"
+            "[rosotacom] The container is not (or no longer) present -- in attach mode it is\n"
+            "[rosotacom] `--rm` and exits with the foreground command. What each pane inside\n"
+            f"[rosotacom] it printed is under {_peer_docker_log(instance, identity).parent / 'catmux'}.",
+        )
+        return
     logs = (result.stdout or "") + (result.stderr or "")
     if logs:
         _append_log(_peer_docker_log(instance, identity), logs)

rosotacom_dev-2.5.dev36/src/rosotacom/resources/ws/ota_configs/cyclonedds_local_participants.xml.template

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+Local-domain CycloneDDS configuration: default discovery, more participants.
+
+Set it as `shared.rmw.local.cyclone.config` (or a peer's `local_config_template`)
+on a machine where many processes share the communication peer's local domain.
+
+Why: Cyclone gives each process one participant index per domain, and its default
+MaxAutoParticipantIndex is 32 - 33 slots per domain per host. A control centre
+spends them faster than that sounds. The processes that start last then lose the
+race, and the error names the domain rather than the cause:
+
+  [46] heartbeat_: Failed to find a free participant index for domain 46
+  [ERROR] [rmw_cyclonedds_cpp]: rmw_create_node: failed to create domain, error Error
+
+On 2026-08-13 that killed the centre's `heartbeat_echo` and one `topic_monitor`
+two seconds after start. catmux left both panes at a shell prompt, so the session
+ran for two hours with no heartbeat publisher: no RTT, no clock-offset estimate,
+and every EchoHeartbeat the far side received carried `echo_valid=false`.
+
+119, not higher: Cyclone's unicast discovery ports are
+7400 + 250*domain + 10 + 2*index, so 119 is the last index whose ports stay
+inside this domain's 250-port block. Index 120 would answer on the next
+domain's ports.
+
+Nothing else is set. This is the *local* domain -- intra-host discovery must keep
+working, so unlike the OTA templates it pins no interface, disables no multicast,
+and sets no peer list.
+-->
+<CycloneDDS xmlns="https://cdds.io/config">
+  <Domain Id="any">
+    <Discovery>
+      <ParticipantIndex>auto</ParticipantIndex>
+      <MaxAutoParticipantIndex>119</MaxAutoParticipantIndex>
+    </Discovery>
+  </Domain>
+</CycloneDDS>

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/src/rosotacom/resources/ws/ros2src/com_py/com_py/link_bytes.py

@@ -78,6 +78,19 @@ def parse_ip_addr_for_ip(text: str, ip: str) -> Optional[str]:
     return None
 
 
+#: Interface names that carry intra-host traffic only. Sampling one of these and
+#: calling the result "link bandwidth" is the failure of issue #267: the number
+#: is real, it is just not the link. On a machine that also runs a `-a` recorder
+#: it reads ~28 Gbit/s next to a 6 Mbit/s OTA link.
+LOOPBACK_INTERFACES = frozenset({"lo", "lo0"})
+
+
+def is_loopback_address(ip: str) -> bool:
+    """Is ``ip`` a loopback address (so a loopback interface would be correct)?"""
+    ip = (ip or "").strip()
+    return ip.startswith("127.") or ip in {"::1", "0:0:0:0:0:0:0:1"}
+
+
 def find_interface_for_ip(ip: str) -> Optional[str]:
     """The interface owning ``ip``, via `ip -o addr show` (None if not found)."""
     if not ip:
@@ -91,6 +104,40 @@ def find_interface_for_ip(ip: str) -> Optional[str]:
     return parse_ip_addr_for_ip(out, ip)
 
 
+def resolve_link_interface(
+    explicit: str,
+    host_ip: str,
+    finder=find_interface_for_ip,
+) -> Tuple[str, str]:
+    """The OTA link interface and where it came from, or raise.
+
+    ``explicit`` wins when given; otherwise the interface is the one owning
+    ``host_ip`` (the peer's own OTA address). A loopback interface for a
+    non-loopback address is refused rather than reported: loopback carries this
+    host's own ROS traffic, which on a machine running an ``-a`` recorder is
+    three orders of magnitude above the link and looks like a working
+    measurement. That mistake is issue #267; it survived a field session and an
+    offline analysis before anyone doubted the number.
+    """
+    interface = (explicit or "").strip()
+    provenance = "given explicitly"
+    if not interface:
+        interface = (finder(host_ip) or "").strip()
+        provenance = f"resolved from {host_ip}"
+    if not interface:
+        raise ValueError(
+            f"no interface owns the OTA address '{host_ip}'; "
+            "pass ip_local (preferred) or interface"
+        )
+    if interface in LOOPBACK_INTERFACES and not is_loopback_address(host_ip):
+        raise ValueError(
+            f"refusing to report loopback interface '{interface}' as the link for OTA "
+            f"address '{host_ip}' ({provenance}). Loopback carries this host's own ROS "
+            "traffic, not the link."
+        )
+    return interface, provenance
+
+
 def read_iface_counters(iface: str, proc_path: str = PROC_NET_DEV) -> Optional[Tuple[int, int]]:
     """Return (rx_bytes, tx_bytes) for ``iface`` now, or None if unavailable."""
     row = read_iface_counter_row(iface, proc_path)

{rosotacom_dev-2.5.dev34 → rosotacom_dev-2.5.dev36}/src/rosotacom/resources/ws/ros2src/com_py/com_py/status_overview.py

@@ -67,9 +67,10 @@ from rclpy.qos import DurabilityPolicy, HistoryPolicy, QoSProfile, ReliabilityPo
 from rclpy.serialization import serialize_message
 from rosidl_runtime_py.utilities import get_message
 
-from com_py.link_bytes import LinkByteSampler, find_interface_for_ip
+from com_py.link_bytes import LinkByteSampler, resolve_link_interface
 from com_py.link_trace import LinkTraceRecorder
 from com_py.status_overview_core import (
+    STARTUP_GRACE_S,
     ClockOffsetEstimator,
     StageObservation,
     StatusAggregator,
@@ -334,6 +335,8 @@ class StatusOverview(Node):
         self.declare_parameter("link_trace_interval_s", 1.0)
         self.declare_parameter("link_trace_modem_command", "")
         self.declare_parameter("link_trace_modem_timeout_s", 2.0)
+        # Grace before the one-shot startup verdict (#266). 0 disables it.
+        self.declare_parameter("startup_grace_s", STARTUP_GRACE_S)
 
         spec_file = str(self.get_parameter("status_spec_file").value or "").strip()
         output_dir = str(self.get_parameter("output_dir").value or "").strip()
@@ -410,20 +413,23 @@ class StatusOverview(Node):
 
         ota_interface = str(self.get_parameter("ota_interface").value or "").strip()
         ota_local_ip = str(self.get_parameter("ota_local_ip").value or "").strip()
-        if not ota_interface and ota_local_ip:
-            ota_interface = find_interface_for_ip(ota_local_ip) or ""
-            if not ota_interface:
+        link_sampler = None
+        if ota_interface or ota_local_ip:
+            # Same resolution and the same loopback refusal as topic_monitor: a
+            # link number nobody can tell apart from loopback traffic is worse
+            # than no link number, so this reports nothing rather than that.
+            try:
+                ota_interface, provenance = resolve_link_interface(ota_interface, ota_local_ip)
+            except ValueError as exc:
+                self.get_logger().warning(
+                    f"status_overview: {exc}; link-overhead measurement disabled"
+                )
+            else:
+                link_sampler = LinkByteSampler(ota_interface)
                 self.get_logger().info(
-                    f"status_overview: no interface found for OTA address '{ota_local_ip}'; "
-                    "link-overhead measurement disabled"
+                    f"status_overview: link-overhead sampling on interface "
+                    f"'{ota_interface}' ({provenance})"
                 )
-        link_sampler = None
-        if ota_interface:
-            link_sampler = LinkByteSampler(ota_interface)
-            self.get_logger().info(
-                f"status_overview: link-overhead sampling on interface '{ota_interface}'"
-                + (f" (resolved from {ota_local_ip})" if ota_local_ip else "")
-            )
 
         link_trace_recorder = None
         if bool(self.get_parameter("link_trace").value):
@@ -450,6 +456,7 @@ class StatusOverview(Node):
             link_sampler=link_sampler,
             clock_estimator=clock_estimator,
             link_trace_recorder=link_trace_recorder,
+            startup_grace_s=float(self.get_parameter("startup_grace_s").value),
         )
 
         self.create_timer(self.write_interval_s, self._on_write)