Struct Encoder 

pub struct Encoder<W: Write = Vec<u8>> { /* private fields */ }

Trace file encoder.

Writes the binary file header, registers event schemas, interns strings into a pool, and encodes events with delta-compressed timestamps.

The default type parameter (Vec<u8>) buffers everything in memory; use Encoder::new_to to write to an arbitrary Write sink.

Implementations

impl Encoder<Vec<u8>>

pub fn new() -> Self

pub fn finish(self) -> Vec<u8>

Consume the encoder and return the encoded bytes.

impl<W: Write> Encoder<W>

pub fn new_to(writer: W) -> Result<Self>

Create an encoder that writes to an arbitrary writer. Writes the file header immediately.

pub fn into_inner(self) -> W

Consume the encoder and return the inner writer.

pub fn as_inner(&self) -> &W

Borrow the inner writer.

pub fn bytes_written(&self) -> u64

Total bytes written through this encoder (including the file header).

pub fn reset_to(&mut self, new_writer: W) -> Result<W>

Reset the encoder to a new writer, preserving internal allocations. Returns the old writer. Writes a file header to the new writer.

pub fn register_schema( &mut self, name: &str, fields: Vec<FieldDef>, ) -> Result<Schema>

Register a schema by name. Returns a Schema handle that can be passed to write_event (on this or any other encoder).

All schemas have timestamps. When writing events, the first element of values must be FieldValue::Varint(timestamp_ns). It is extracted and encoded in the event header (not as a regular field).

Eagerly writes the schema frame. Idempotent if the definition matches.

pub fn write_event( &mut self, schema: &Schema, values: &[FieldValue], ) -> Result<()>

Write an event for a schema.

The first element of values must be FieldValue::Varint(timestamp_ns) — it is extracted and encoded in the event header, not as a regular field. The remaining values must match the schema’s field count.

If this encoder hasn’t seen schema before, it is auto-registered (the schema frame is written before the event).

pub fn write<T: TraceEvent + 'static>(&mut self, event: &T) -> Result<()>

Write a derived TraceEvent. Auto-registers the schema on first call for this type. Handles timestamp encoding: emits TimestampReset if needed, packs u24 delta in header.

pub fn intern_string(&mut self, s: &str) -> Result<InternedString>

Intern a string, emitting a pool frame if new. Returns an InternedString handle.

pub fn write_string_pool(&mut self, entries: &[PoolEntry]) -> Result<()>

pub fn intern_stack_frames( &mut self, frames: &[u64], ) -> Result<InternedStackFrames>

Intern a stack-frame vector, emitting a stack-pool frame if new. Returns an InternedStackFrames handle.

pub fn write_stack_pool(&mut self, entries: &[StackPoolEntry]) -> Result<()>

pub fn flush(&mut self) -> Result<()>

Flush the underlying writer.

pub fn into_raw_encoder(self) -> RawEncoder<W>

Convert this encoder into a RawEncoder that only supports writing pre-encoded bytes. The byte count is preserved so rotation decisions remain correct.

Use this after writing any structured data (headers, segment metadata) to switch to a raw-only mode for appending pre-encoded batches.

impl Encoder<Vec<u8>>

pub fn write_infallible<T: TraceEvent + 'static>(&mut self, event: &T)

pub fn intern_string_infallible(&mut self, s: &str) -> InternedString

pub fn intern_stack_frames_infallible( &mut self, frames: &[u64], ) -> InternedStackFrames

pub fn reset_to_infallible(&mut self, data: Vec<u8>) -> Vec<u8>

Resets the encoder to point to a new backing Vec returning the old one

Trait Implementations

impl Default for Encoder<Vec<u8>>

fn default() -> Self

Returns the “default value” for a type.