Struct TelemetryPipe 

pub struct TelemetryPipe { /* private fields */ }

A running telemetry pipe. Created by OfflineProtocol::enable_telemetry and stopped by disable_telemetry or by being dropped.

Implementations

impl TelemetryPipe

pub fn set_enabled(&self, enabled: bool)

Stops or resumes collection. Off, an emit costs one atomic load and nothing is buffered; what is already queued still drains.

Resuming restamps the summary anchor. The duration is the one summary field derived from a clock rather than accumulated from records, so unlike every counter it keeps growing while collection is off, and the first row afterwards would otherwise bill the entire opt-out. Only the off-to-on edge does this, so repeated set_enabled(true) calls on a live pipe do not keep resetting the span.

pub fn is_enabled(&self) -> bool

Whether collection is on.

pub fn flush(&self)

Asks the uploader to flush now. Returns immediately.

pub fn flush_blocking(&self, budget: Duration) -> bool

Flushes and waits up to budget for the uploader to finish the cycle. Returns whether it finished in time.

pub fn stats(&self) -> TelemetryStats

A snapshot of the counters.

pub fn end_session(&self)

Closes the current session: summary, a blocking flush within FINAL_FLUSH_BUDGET, then a fresh session id.

A no-op while collection is off, for the reason given on Self::notify_app_state. Self::flush is the call that pushes a queued backlog without collecting anything new.

pub fn notify_app_state(&self, state: AppState)

Reports an application lifecycle transition.

While collection is off the transition is recorded but nothing is emitted. A session summary is collection: it is a row the ingest stores and bills, carrying the session duration and every counter the pairer accumulated, so emitting one for a user who switched telemetry off would break the promise docs/telemetry.md makes for that switch. The edge is still tracked, so the next foreground after collection resumes rotates the session rather than being read as a non-edge.

pub fn stop(&self, budget: Duration) -> bool

Stops the uploader after one final flush, waiting up to budget for the thread to exit before detaching it. Idempotent.

pub fn is_stopped(&self) -> bool

Whether stop has run.

pub fn is_durable(&self) -> bool

Whether the batch queue is mirrored to storage.

Reads an atomic rather than the store mutex, which the uploader holds across a request: a caller asking a question about configuration must not be parked behind a fifteen-second socket timeout.

Trait Implementations

impl Debug for TelemetryPipe

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for TelemetryPipe

fn drop(&mut self)

Signals the final flush and detaches the worker without waiting for it.

The flush still happens, bounded by FINAL_FLUSH_BUDGET on the worker’s own thread; what the dropping thread does not do is block for it. A drop lands wherever the last handle happens to be released, and on the mobile bindings that is a teardown path: iOS releases native modules on the main thread during a bridge reload, so waiting here put three seconds inside the scene-update watchdog’s window. A caller that needs to observe the flush calls Self::stop with a budget first, which is what disable_telemetry does.

An inline pipe is the exception, and only because it has to be: with no worker there is no other thread to run the flush on, so the dropping thread is the only one that can. That configuration is the tests and the benches, never a shipped binary.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.