Struct RecordingStream 

pub struct RecordingStream { /* private fields */ }

A RecordingStream handles everything related to logging data into Rerun.

You can construct a new RecordingStream using RecordingStreamBuilder or RecordingStream::new.

Sinks

Data is logged into Rerun via LogSinks.

The underlying LogSink of a RecordingStream can be changed at any point during its lifetime by calling RecordingStream::set_sink or one of the higher level helpers (RecordingStream::connect_grpc, RecordingStream::memory, RecordingStream::save, RecordingStream::disconnect).

See RecordingStream::set_sink for more information.

Multithreading and ordering

RecordingStream can be cheaply cloned and used freely across any number of threads.

Internally, all operations are linearized into a pipeline:

• All operations sent by a given thread will take effect in the same exact order as that thread originally sent them in, from its point of view.
• There isn’t any well defined global order across multiple threads.

This means that e.g. flushing the pipeline (Self::flush_blocking) guarantees that all previous data sent by the calling thread has been recorded and (if applicable) flushed to the underlying OS-managed file descriptor, but other threads may still have data in flight.

Shutdown

The RecordingStream can only be shutdown by dropping all instances of it, at which point it will automatically take care of flushing any pending data that might remain in the pipeline.

Shutting down cannot ever block.

Implementations

impl RecordingStream

pub fn get( kind: StoreKind, overrides: Option<RecordingStream>, ) -> Option<RecordingStream>

Returns overrides if it exists, otherwise returns the most appropriate active recording of the specified type (i.e. thread-local first, then global scope), if any.

pub fn global(kind: StoreKind) -> Option<RecordingStream>

Returns the currently active recording of the specified type in the global scope, if any.

pub fn set_global( kind: StoreKind, rec: Option<RecordingStream>, ) -> Option<RecordingStream>

Replaces the currently active recording of the specified type in the global scope with the specified one.

Returns the previous one, if any.

pub fn forget_global(kind: StoreKind)

Forgets the currently active recording of the specified type in the global scope.

WARNING: this intentionally bypasses any drop/flush logic. This should only ever be used in cases where you know the batcher/sink threads have been lost such as in a forked process.

pub fn thread_local(kind: StoreKind) -> Option<RecordingStream>

Returns the currently active recording of the specified type in the thread-local scope, if any.

pub fn set_thread_local( kind: StoreKind, rec: Option<RecordingStream>, ) -> Option<RecordingStream>

Replaces the currently active recording of the specified type in the thread-local scope with the specified one.

pub fn forget_thread_local(kind: StoreKind)

Forgets the currently active recording of the specified type in the thread-local scope.

WARNING: this intentionally bypasses any drop/flush logic. This should only ever be used in cases where you know the batcher/sink threads have been lost such as in a forked process.

impl RecordingStream

pub fn clone_weak(&self) -> RecordingStream

Clones the RecordingStream without incrementing the refcount.

Useful e.g. if you want to make sure that a detached thread won’t prevent the RecordingStream from flushing during shutdown.

pub fn ref_count(&self) -> usize

Returns the current reference count of the RecordingStream.

Returns 0 if the stream was created by RecordingStream::disabled(), or if it is a clone_weak() of a stream whose strong instances have all been dropped.

impl RecordingStream

pub fn new( store_info: StoreInfo, recording_info: Option<RecordingInfo>, batcher_config: Option<ChunkBatcherConfig>, batcher_hooks: BatcherHooks, sink: Box<dyn LogSink>, ) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream with a given StoreInfo and LogSink.

You can create a StoreInfo with crate::new_store_info;

The StoreInfo is immediately sent to the sink in the form of a re_log_types::SetStoreInfo.

You can find sinks in crate::sink.

If no batcher configuration is provided, the default batcher configuration for the sink will be used. Any environment variables as specified in ChunkBatcherConfig will always override respective settings.

See also: RecordingStreamBuilder.

pub const fn disabled() -> RecordingStream

Creates a new no-op RecordingStream that drops all logging messages, doesn’t allocate any memory and doesn’t spawn any threads.

Self::is_enabled will return false.

impl RecordingStream

pub fn log<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>

where AS: AsComponents + ?Sized,

Log data to Rerun.

This is the main entry point for logging data to rerun. It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

The data will be timestamped automatically based on the RecordingStream’s internal clock. See RecordingStream::set_time_sequence etc for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/logging-and-ingestion/entity-path for more on entity paths.

See also: Self::log_static for logging static data.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

Example:

rec.log(
    "my/points",
    &rerun::Points3D::new([(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)]),
)?;

Thread Safety

While RecordingStream is Send + Sync and safe to use from multiple threads, avoid calling log while holding a std::sync::Mutex. The rerun SDK uses rayon internally for parallel processing, and rayon’s work-stealing behavior can cause deadlocks when combined with held mutexes (see rayon#592).

// ❌ Don't do this - potential deadlock:
let guard = mutex.lock().unwrap();
stream.log("data", &rerun::Points3D::new(points))?;
drop(guard);

// ✅ Do this instead - extract data first:
let points = {
    let guard = mutex.lock().unwrap();
    guard.points.clone()
};
stream.log("data", &rerun::Points3D::new(points))?;

pub fn send_columns( &self, ent_path: impl Into<EntityPath>, indexes: impl IntoIterator<Item = TimeColumn>, columns: impl IntoIterator<Item = SerializedComponentColumn>, ) -> Result<(), RecordingStreamError>

Lower-level logging API to provide data spanning multiple timepoints.

Unlike the regular log API, which is row-oriented, this API lets you submit the data in a columnar form. The lengths of all of the TimeColumn and the component columns must match. All data that occurs at the same index across the different index/time and components arrays will act as a single logical row.

Note that this API ignores any stateful index/time set on the log stream via the Self::set_time/Self::set_timepoint/etc. APIs. Furthermore, this will not inject the default timelines log_tick and log_time timeline columns.

pub fn log_static<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>

where AS: AsComponents + ?Sized,

Log data to Rerun.

It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type. All timestamp data associated with this message will be dropped right before sending it to Rerun.

This is most often used for rerun::ViewCoordinates and rerun::AnnotationContext.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

See also Self::log.

pub fn log_with_static<AS>( &self, ent_path: impl Into<EntityPath>, static_: bool, as_components: &AS, ) -> Result<(), RecordingStreamError>

where AS: AsComponents + ?Sized,

Logs the contents of a component bundle into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the RecordingStream’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/logging-and-ingestion/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn log_serialized_batches( &self, ent_path: impl Into<EntityPath>, static_: bool, comp_batches: impl IntoIterator<Item = SerializedComponentBatch>, ) -> Result<(), RecordingStreamError>

Logs a set of SerializedComponentBatches into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the RecordingStream’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The number of instances will be determined by the longest batch in the bundle.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/logging-and-ingestion/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn send_property<AS>( &self, name: impl Into<String>, values: &AS, ) -> Result<(), RecordingStreamError>

where AS: AsComponents + ?Sized,

Sends a property to the recording.

pub fn send_recording_name( &self, name: impl Into<String>, ) -> Result<(), RecordingStreamError>

Sends the name of the recording.

pub fn send_recording_start_time( &self, timestamp: impl Into<Timestamp>, ) -> Result<(), RecordingStreamError>

Sends the start time of the recording.

pub fn log_file_from_path( &self, filepath: impl AsRef<Path>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the file at the given path using all re_importer::Importers available.

A single path might be handled by more than one importer.

This method blocks until either at least one re_importer::Importer starts streaming data in or all of them fail.

See https://www.rerun.io/docs/concepts/logging-and-ingestion/importers/overview for more information.

pub fn log_file_from_contents( &self, filepath: impl AsRef<Path>, contents: Cow<'_, [u8]>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the given contents using all re_importer::Importers available.

A single path might be handled by more than one importer.

This method blocks until either at least one re_importer::Importer starts streaming data in or all of them fail.

See https://www.rerun.io/docs/concepts/logging-and-ingestion/importers/overview for more information.

impl RecordingStream

pub fn is_enabled(&self) -> bool

Check if logging is enabled on this RecordingStream.

If not, all recording calls will be ignored.

pub fn store_info(&self) -> Option<StoreInfo>

The StoreInfo associated with this RecordingStream.

pub fn is_forked_child(&self) -> bool

Determine whether a fork has happened since creating this RecordingStream. In general, this means our batcher/sink threads are gone and all data logged since the fork has been dropped.

It is essential that crate::cleanup_if_forked_child be called after forking the process. SDK-implementations should do this during their initialization phase.

impl RecordingStream

pub fn record_msg(&self, msg: LogMsg)

Records an arbitrary LogMsg.

pub fn record_row( &self, entity_path: EntityPath, row: PendingRow, inject_time: bool, )

Records a single PendingRow.

If inject_time is set to true, the row’s timestamp data will be overridden using the RecordingStream’s internal clock.

Internally, incoming PendingRows are automatically coalesced into larger Chunks to optimize for transport.

pub fn log_chunk(&self, chunk: Chunk)

Logs a single Chunk.

Will inject the log_time timeline column (and log_tick if enabled) into the chunk. If you don’t want to inject these, use Self::send_chunk instead.

pub fn log_chunks(&self, chunks: impl IntoIterator<Item = Chunk>)

Logs multiple Chunks.

This will not inject log_tick and log_time timeline columns into the chunk, for that use Self::log_chunks.

pub fn send_chunk(&self, chunk: Chunk)

Records a single Chunk.

This will not inject log_tick and log_time timeline columns into the chunk, for that use Self::log_chunk.

pub fn send_chunks(&self, chunks: impl IntoIterator<Item = Chunk>)

Records multiple Chunks.

This will not inject log_tick and log_time timeline columns into the chunk, for that use Self::log_chunks.

pub fn set_sink(&self, new_sink: Box<dyn LogSink>)

Swaps the underlying sink for a new one.

This guarantees that:

1. all pending rows and chunks are batched, collected and sent down the current sink,
2. the current sink is flushed if it has pending data in its buffers,
3. the current sink’s backlog, if there’s any, is forwarded to the new sink.

When this function returns, the calling thread is guaranteed that all future record calls will end up in the new sink.

If the batcher’s configuration has not been set explicitly or by environment variables, this will change the batcher configuration to the sink’s default configuration.

Data loss

If the current sink is in a broken state (e.g. a gRPC sink with a broken connection that cannot be repaired), all pending data in its buffers will be dropped.

pub fn flush_async(&self) -> Result<(), SinkFlushError>

Initiates a flush of the pipeline and returns immediately.

This does not wait for the flush to propagate (see Self::flush_blocking). See RecordingStream docs for ordering semantics and multithreading guarantees.

This will never return SinkFlushError::Timeout.

pub fn flush_blocking(&self) -> Result<(), SinkFlushError>

Flush the batching pipeline and waits for it to propagate.

The function will block until either the flush has completed successfully (Ok), an error has occurred (SinkFlushError::Failed), or the timeout is reached (SinkFlushError::Timeout).

Convenience for calling Self::flush_with_timeout with a timeout of Duration::MAX

pub fn flush_with_timeout( &self, timeout: Duration, ) -> Result<(), SinkFlushError>

Flush the batching pipeline and optionally waits for it to propagate. If you don’t want a timeout you can pass in Duration::MAX.

The function will block until that timeout is reached, an error occurs, or the flush is complete. The function will only block while there is some hope of progress. For instance: if the underlying gRPC connection is disconnected (or never connected at all), then SinkFlushError::Failed is returned.

See RecordingStream docs for ordering semantics and multithreading guarantees.

impl RecordingStream

pub fn set_sinks(&self, sinks: impl IntoMultiSink)

Stream data to multiple different sinks.

This is semantically the same as calling RecordingStream::set_sink, but the resulting RecordingStream will now stream data to multiple sinks at the same time.

Currently only supports GrpcSink and FileSink.

If the batcher’s configuration has not been set explicitly or by environment variables, This will take over a conservative default of the new sinks. (there’s no guarantee on when exactly the new configuration will be active)

pub fn inspect_sink( &self, f: impl FnOnce(&(dyn LogSink + 'static)) + Send + 'static, )

Asynchronously calls a method that has read access to the currently active sink.

Since a recording stream’s sink is owned by a different thread there is no guarantee when the callback is going to be called. It’s advised to return as quickly as possible from the callback since as long as the callback doesn’t return, the sink will not receive any new data,

Experimental

This is an experimental API and may change in future releases.

pub fn connect_grpc(&self) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a crate::log_sink::GrpcSink sink pre-configured to use the specified address.

See also Self::connect_grpc_opts if you wish to configure the connection.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn connect_grpc_opts( &self, url: impl Into<String>, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a crate::log_sink::GrpcSink sink pre-configured to use the specified address.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

flush_timeout is the minimum time the GrpcSink will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

pub fn serve_grpc( &self, server_options: ServerOptions, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a crate::grpc_server::GrpcServerSink pre-configured to listen on rerun+http://127.0.0.1:9876/proxy.

To configure the gRPC server’s IP and port, use Self::serve_grpc_opts instead.

You can connect a viewer to it with rerun --connect.

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_options argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn serve_grpc_opts( &self, bind_ip: impl AsRef<str>, port: u16, server_options: ServerOptions, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a crate::grpc_server::GrpcServerSink pre-configured to listen on rerun+http://{bind_ip}:{port}/proxy.

0.0.0.0 is a good default for bind_ip.

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_options argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn spawn(&self) -> Result<(), RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then swaps the underlying sink for a crate::log_sink::GrpcSink sink pre-configured to send data to that new process.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

See also Self::spawn_opts if you wish to configure the behavior of thew Rerun process as well as the underlying connection.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn spawn_opts( &self, opts: &SpawnOptions, ) -> Result<(), RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then swaps the underlying sink for a crate::log_sink::GrpcSink sink pre-configured to send data to that new process.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

The behavior of the spawned Viewer can be configured via opts. If you’re fine with the default behavior, refer to the simpler Self::spawn.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

flush_timeout is the minimum time the GrpcSink will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

pub fn memory(&self) -> MemorySinkStorage

Swaps the underlying sink for a crate::sink::MemorySink sink and returns the associated MemorySinkStorage.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn binary_stream(&self) -> BinaryStreamStorage

Swaps the underlying sink for a crate::sink::BinaryStreamSink sink and returns the associated BinaryStreamStorage.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn save(&self, path: impl Into<PathBuf>) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink at the specified path.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn save_opts(&self, path: impl Into<PathBuf>) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink at the specified path.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

If a blueprint was provided, it will be stored first in the file. Blueprints are currently an experimental part of the Rust SDK.

pub fn stdout(&self) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink pointed at stdout.

If there isn’t any listener at the other end of the pipe, the RecordingStream will default back to buffered mode, in order not to break the user’s terminal.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn stdout_opts(&self) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink pointed at stdout.

If there isn’t any listener at the other end of the pipe, the RecordingStream will default back to buffered mode, in order not to break the user’s terminal.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

If a blueprint was provided, it will be stored first in the file. Blueprints are currently an experimental part of the Rust SDK.

pub fn disconnect(&self)

Swaps the underlying sink for a crate::sink::BufferedSink.

This is a convenience wrapper for Self::set_sink that upholds the same guarantees in terms of data durability and ordering. See Self::set_sink for more information.

pub fn finalize_deferred_sinks(&self)

Finalize any sinks whose on-disk format only completes at shutdown (i.e. file-like sinks that write a footer at the end), while leaving streaming sinks (e.g. gRPC) intact.

For a bare deferring sink (e.g. FileSink from save()), this is equivalent to Self::disconnect: the sink is replaced with a crate::sink::BufferedSink and its Drop impl runs the writer thread to completion, which is what emits the footer.

For a crate::log_sink::MultiSink containing a mix of deferring and streaming children, only the deferring children are dropped. The streaming children remain live and the MultiSink continues to receive new messages.

For all other sinks this is a no-op.

Used by Python’s RecordingStream.__exit__ so file-backed recordings are consumable as soon as the with-block exits, without waiting for __del__ / GC.

pub fn send_blueprint( &self, blueprint: Vec<LogMsg>, activation_cmd: BlueprintActivationCommand, )

Send a blueprint through this recording stream.

pub fn send_blueprint_opts( &self, opts: &BlueprintOpts, ) -> Result<(), RecordingStreamError>

Send a crate::blueprint::Blueprint to configure the viewer layout.

impl RecordingStream

pub fn now(&self) -> TimePoint

Returns the current time of the recording on the current calling thread.

This is the TimePoint that would be injected into data logged right now from this thread: it contains every user timeline set via Self::set_time and friends, plus the automatic log_time timeline if it is enabled (see Self::set_log_time_enabled).

Note that the automatic log_tick timeline is not included here — it is only assigned at the moment data is actually logged.

Returns an empty TimePoint if the recording is disabled.

See also:

• Self::set_time
• Self::disable_timeline
• Self::reset_time

pub fn set_timepoint(&self, timepoint: impl Into<TimePoint>)

Set the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

• Self::set_time
• Self::set_time_sequence
• Self::set_duration_secs
• Self::disable_timeline
• Self::reset_time

pub fn set_time( &self, timeline: impl Into<TimelineName>, value: impl TryInto<TimeCell>, )

Set the current value of one of the timelines.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

There is no requirement of monotonicity. You can move the time backwards if you like.

Example:

rec.set_time("frame_nr", rerun::TimeCell::from_sequence(42));
rec.set_time("duration", std::time::Duration::from_millis(123));
rec.set_time("capture_time", std::time::SystemTime::now());

See also:

• Self::set_timepoint
• Self::set_time_sequence
• Self::set_duration_secs
• Self::disable_timeline
• Self::reset_time

pub fn set_time_sequence( &self, timeline: impl Into<TimelineName>, sequence: impl Into<i64>, )

Set the current time of the recording, for the current calling thread.

Short for set_time(timeline, rerun::TimeCell::from_sequence(sequence)).

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_time_sequence("frame_nr", frame_nr). You can remove a timeline again using rec.disable_timeline("frame_nr").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

• Self::set_time
• Self::set_timepoint
• Self::set_duration_secs
• Self::disable_timeline
• Self::reset_time

pub fn set_duration_secs( &self, timeline: impl Into<TimelineName>, secs: impl Into<f64>, )

Set the current time of the recording, for the current calling thread.

Short for set_time(timeline, std::time::Duration::from_secs_f64(secs))..

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_duration_secs("time_since_start", time_offset). You can remove a timeline again using rec.disable_timeline("time_since_start").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

• Self::set_time
• Self::set_timepoint
• Self::set_timestamp_secs_since_epoch
• Self::set_time_sequence
• Self::disable_timeline
• Self::reset_time

pub fn set_timestamp_secs_since_epoch( &self, timeline: impl Into<TimelineName>, secs: impl Into<f64>, )

Set a timestamp as seconds since Unix epoch (1970-01-01 00:00:00 UTC).

Short for self.set_time(timeline, rerun::TimeCell::from_timestamp_secs_since_epoch(secs)).

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

You can remove a timeline again using rec.disable_timeline(timeline).

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

• Self::set_time
• Self::set_timepoint
• Self::set_duration_secs
• Self::set_time_sequence
• Self::set_timestamp_nanos_since_epoch
• Self::disable_timeline
• Self::reset_time

pub fn set_timestamp_nanos_since_epoch( &self, timeline: impl Into<TimelineName>, nanos: impl Into<i64>, )

Set a timestamp as nanoseconds since Unix epoch (1970-01-01 00:00:00 UTC).

Short for self.set_time(timeline, rerun::TimeCell::set_timestamp_nanos_since_epoch(secs)).

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

You can remove a timeline again using rec.disable_timeline(timeline).

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

• Self::set_time
• Self::set_timepoint
• Self::set_duration_secs
• Self::set_time_sequence
• Self::set_timestamp_secs_since_epoch
• Self::disable_timeline
• Self::reset_time

pub fn disable_timeline(&self, timeline: impl Into<TimelineName>)

Clears out the current time of the recording for the specified timeline, for the current calling thread.

For example: rec.disable_timeline("frame"), rec.disable_timeline("sim_time").

See also:

• Self::set_timepoint
• Self::set_time_sequence
• Self::reset_time

pub fn reset_time(&self)

Clears out the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.reset_time().

See also:

• Self::set_timepoint
• Self::set_time_sequence
• Self::disable_timeline

pub fn log_tick_enabled(&self) -> bool

Whether the log_tick timeline is automatically injected into logged data.

Defaults to false (opt-in), overridable via the RERUN_LOG_TICK env-var. See also Self::set_log_tick_enabled.

pub fn log_time_enabled(&self) -> bool

Whether the log_time timeline is automatically injected into logged data.

Defaults to true (opt-out), overridable via the RERUN_LOG_TIME env-var. See also Self::set_log_time_enabled.

pub fn set_log_tick_enabled(&self, enabled: bool)

Enable or disable automatic injection of the log_tick timeline into logged data.

log_tick is a per-recording counter that increments on every logging call. It is disabled by default; this lets you turn it on (or off) at runtime, overriding the RERUN_LOG_TICK env-var.

See also Self::set_log_time_enabled.

pub fn set_log_time_enabled(&self, enabled: bool)

Enable or disable automatic injection of the log_time timeline into logged data.

log_time is the wall-clock time at which data was logged. It is enabled by default; this lets you turn it off (or on) at runtime, overriding the RERUN_LOG_TIME env-var.

See also Self::set_log_tick_enabled.

Trait Implementations

impl Clone for RecordingStream

fn clone(&self) -> RecordingStream

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RecordingStream

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

Formats the value using the given formatter.

impl Drop for RecordingStream

fn drop(&mut self)

Executes the destructor for this type.

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.