fix: rate-limit rerun bridge to prevent viewer OOM

[spomichter]

Problem

After ~1 hour of running unitree-go2-agentic with the native Rerun viewer (stock or dimos-viewer), the system locks up:

• All CPU workers at 80%+
• RAM 30GB/31GB, swap 30GB/30GB
• Renderer crashpad handler messages

Killing the viewer process recovers the system — proving the viewer process is the memory hog.

Root Cause

Rerun's memory_limit only governs the chunk store (data it can GC). It does not control GPU texture memory, render buffers, or texture caches. When 30fps camera images are logged unthrottled, the renderer's texture cache grows unbounded even though the chunk store stays within limits.

This is upstream Rerun behavior — affects both stock rerun and dimos-viewer.

Fix

Per-entity-path rate limiting in RerunBridgeModule._on_message():

• Default: 10 Hz max per entity path (min_interval_sec=0.1)
• Drops frames between intervals instead of logging every one
• Configurable: set min_interval_sec=0 to disable for low-bandwidth deployments
• 30fps camera → 10fps to viewer = 3x less texture memory pressure

Changes

• bridge.py: Add min_interval_sec to Config, rate-limit in _on_message()
• No viewer rebuild needed
• No breaking changes (new config field has default value)

[greptile-apps]

Greptile Summary

This PR adds per-entity-path rate limiting to RerunBridgeModule._on_message() to prevent the Rerun viewer's GPU texture cache from growing unbounded when high-frequency camera streams are logged, which was causing OOM crashes after ~1 hour of operation.

Key changes:

• New min_interval_sec: float = 0.1 field on Config (default 10 Hz cap per entity path; set to 0 to disable)
• Guard in _on_message that drops incoming frames for an entity path if the elapsed time since its last logged frame is less than min_interval_sec
• No breaking changes — new config field defaults to the rate-limited behaviour

Issues found:

• The _last_log dict is lazily created inside the hot message path via hasattr(self, "_last_log"), which is evaluated on every single incoming message. Initialising the dict once in start() (before subscriptions begin) removes the per-call check and eliminates a benign but unnecessary concurrent-write window.
• _last_log[entity_path] is written before _visual_override_for_entity_path is called, so if an override converter conditionally returns None, the rate-limit slot is consumed even though no frame was actually logged to the viewer. For always-suppressed topics this is harmless, but for conditional filters it means the effective output rate can be lower than 1/min_interval_sec.

Confidence Score: 4/5

• Safe to merge — the change is a targeted, well-documented fix with a sound default and no breaking changes.
• The logic is correct and the OOM root cause is well understood. The only concerns are a minor hot-path hasattr pattern and a pre-update timestamp ordering issue that only affects conditional suppression scenarios; neither will cause incorrect behaviour in the primary use case.
• No files require special attention beyond the two style-level suggestions on bridge.py.

Important Files Changed

Filename	Overview
dimos/visualization/rerun/bridge.py	Adds per-entity-path rate limiting (default 10 Hz) to _on_message via a new min_interval_sec config field; implementation is correct and non-breaking, with minor style concerns around lazy dict initialisation in the hot path and updating the rate-limit timestamp before confirming data is non-null.

Sequence Diagram

sequenceDiagram
    participant PS as PubSub
    participant BM as RerunBridgeModule._on_message()
    participant RL as Rate Limiter (_last_log)
    participant VO as _visual_override_for_entity_path()
    participant RR as rerun (viewer)

    PS->>BM: message + topic
    BM->>BM: _get_entity_path(topic) → entity_path

    alt min_interval_sec > 0
        BM->>RL: get last timestamp for entity_path
        alt now - last < min_interval_sec
            BM-->>PS: return (frame dropped)
        else interval elapsed
            RL-->>BM: update _last_log[entity_path] = now
        end
    end

    BM->>VO: lookup converter for entity_path (lru_cache)
    VO-->>BM: converter fn

    BM->>BM: converter(msg) → rerun_data

    alt rerun_data is None (suppressed)
        BM-->>PS: return
    else is_rerun_multi(rerun_data)
        loop each (path, archetype)
            BM->>RR: rr.log(path, archetype)
        end
    else single Archetype
        BM->>RR: rr.log(entity_path, rerun_data)
    end

Loading

_{Last reviewed commit: 4b37511}

[greptile-apps]

Lazy _last_log init in hot message path

_on_message is called on every incoming pubsub message (potentially hundreds per second). The hasattr(self, "_last_log") check is evaluated on each call, every time rate-limiting is enabled. Beyond the minor per-call overhead, there is a benign but avoidable race: if two pubsub threads deliver a message simultaneously before _last_log is set, both branches execute and one thread's empty dict silently overwrites the other's.

Prefer initialising _last_log once in start(), before subscriptions begin, so the attribute always exists and the hot path is reduced to a single dict lookup:

# inside start(), before the subscribe_all loop:
self._last_log: dict[str, float] = {}

Then the hot-path block simplifies to:

Suggested change

	if not hasattr(self, "_last_log"):
	self._last_log: dict[str, float] = {}
	if self.config.min_interval_sec > 0:
	now = time.monotonic()
	last = self._last_log.get(entity_path, 0.0)
	if now - last < self.config.min_interval_sec:
	return
	self._last_log[entity_path] = now

[greptile-apps]

Timestamp updated even when message is suppressed downstream

_last_log[entity_path] is written here — before _visual_override_for_entity_path is called. If the override converter returns None (i.e., the topic is suppressed), the slot is still "consumed" for this interval: the next arriving message for that entity path will be dropped by the rate limiter even though no frame was actually logged.

For purely suppressed topics this is harmless (nothing ever logs anyway), but for topics whose override sometimes returns None (e.g., conditional filtering), frames can be silently skipped at a lower effective rate than 1/min_interval_sec.

Consider moving the timestamp update to just before the rr.log calls, after confirming rerun_data is not None:

if self.config.min_interval_sec > 0:
    now = time.monotonic()
    last = self._last_log.get(entity_path, 0.0)
    if now - last < self.config.min_interval_sec:
        return
    # defer: update timestamp only after data is confirmed non-None