Struct re_sdk::RecordingStreamBuilder

pub struct RecordingStreamBuilder { /* private fields */ }

Construct a RecordingStream.

let rec = RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

Implementations

impl RecordingStreamBuilder

pub fn new(application_id: impl Into<ApplicationId>) -> Self

Create a new RecordingStreamBuilder with the given ApplicationId.

The ApplicationId is usually the name of your app.

let rec = RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

pub fn default_enabled(self, default_enabled: bool) -> Self

Set whether or not Rerun is enabled by default.

If the RERUN environment variable is set, it will override this.

Set also: Self::enabled.

pub fn enabled(self, enabled: bool) -> Self

Set whether or not Rerun is enabled.

Setting this will ignore the RERUN environment variable.

Set also: Self::default_enabled.

pub fn store_id(self, store_id: StoreId) -> Self

Set the StoreId for this context.

If you’re logging from multiple processes and want all the messages to end up as the same store, you must make sure they all set the same StoreId using this function.

Note that many stores can share the same ApplicationId, but they all have unique StoreIds.

The default is to use a random StoreId.

pub fn batcher_config(self, config: DataTableBatcherConfig) -> Self

Specifies the configuration of the internal data batching mechanism.

See DataTableBatcher & DataTableBatcherConfig for more information.

pub fn buffered(self) -> RecordingStreamResult<RecordingStream>

Creates a new RecordingStream that starts in a buffering state (RAM).

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").buffered()?;

pub fn memory( self ) -> RecordingStreamResult<(RecordingStream, MemorySinkStorage)>

Creates a new RecordingStream that is pre-configured to stream the data through to a crate::log_sink::MemorySink.

Example

let (rec, storage) = re_sdk::RecordingStreamBuilder::new("rerun_example_app").memory()?;

log_data(&rec);

let data = storage.take();

pub fn connect(self) -> RecordingStreamResult<RecordingStream>

Creates a new RecordingStream that is pre-configured to stream the data through to a remote Rerun instance.

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

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").connect()?;

pub fn connect_opts( self, addr: SocketAddr, flush_timeout: Option<Duration> ) -> RecordingStreamResult<RecordingStream>

Creates a new RecordingStream that is pre-configured to stream the data through to a remote Rerun instance.

flush_timeout is the minimum time the TcpSink 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.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .connect_opts(re_sdk::default_server_addr(), re_sdk::default_flush_timeout())?;

pub fn save( self, path: impl Into<PathBuf> ) -> RecordingStreamResult<RecordingStream>

Creates a new RecordingStream that is pre-configured to stream the data through to an RRD file on disk.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

pub fn spawn(self) -> RecordingStreamResult<RecordingStream>

Spawns a new Rerun Viewer process from an executable available in PATH, then creates a new RecordingStream that is pre-configured to stream the data through to that viewer over TCP.

If a Rerun Viewer is already listening on this TCP 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 TCP connection.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").spawn()?;

pub fn spawn_opts( self, opts: &SpawnOptions, flush_timeout: Option<Duration> ) -> RecordingStreamResult<RecordingStream>

Spawns a new Rerun Viewer process from an executable available in PATH, then creates a new RecordingStream that is pre-configured to stream the data through to that viewer over TCP.

If a Rerun Viewer is already listening on this TCP 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.

flush_timeout is the minimum time the TcpSink 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.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .spawn_opts(&re_sdk::SpawnOptions::default(), re_sdk::default_flush_timeout())?;

pub fn serve( self, bind_ip: &str, web_port: WebViewerServerPort, ws_port: RerunServerPort, open_browser: bool ) -> RecordingStreamResult<RecordingStream>

Creates a new RecordingStream that is pre-configured to stream the data through to a web-based Rerun viewer via WebSockets.

This method needs to be called in a context where a Tokio runtime is already running (see example below).

If the open_browser argument is true, your default browser will be opened with a connected web-viewer.

If not, you can connect to this server using the rerun binary (cargo install rerun-cli).

Example

// Ensure we have a running tokio runtime.
let mut tokio_runtime = None;
let tokio_runtime_handle = if let Ok(handle) = tokio::runtime::Handle::try_current() {
    handle
} else {
    let rt = tokio::runtime::Runtime::new().expect("Failed to create tokio runtime");
    tokio_runtime.get_or_insert(rt).handle().clone()
};
let _tokio_runtime_guard = tokio_runtime_handle.enter();

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .serve("0.0.0.0", Default::default(), Default::default(), true)?;

pub fn into_args(self) -> (bool, StoreInfo, DataTableBatcherConfig)

Returns whether or not logging is enabled, a StoreInfo and the associated batcher configuration.

This can be used to then construct a RecordingStream manually using RecordingStream::new.

Trait Implementations

impl Debug for RecordingStreamBuilder

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

Formats the value using the given formatter.