Struct LogsBuilder 

pub struct LogsBuilder {

    id: UInt32Builder,
    time: TimestampNanosecondBuilder,
    observed: TimestampNanosecondBuilder,
    sev_num: Int32Builder,
    sev_text: DictColumn,
    event_name: DictColumn,
    body: StringBuilder,
    body_ser: BinaryBuilder,
    trace_id: FixedSizeBinaryBuilder,
    span_id: FixedSizeBinaryBuilder,
    flags: UInt32Builder,
    dropped: UInt32Builder,
    resource_id: UInt16Builder,
    scope_id: UInt16Builder,
    log_attrs: AttrsBuilder,
    rs: ResourceScope,
    next_id: u32,
    min_ts: i64,
    max_ts: i64,
}

Fields

id: UInt32Builder

time: TimestampNanosecondBuilder

observed: TimestampNanosecondBuilder

sev_num: Int32Builder

sev_text: DictColumn

Twenty-four distinct values in practice, unbounded from a hostile client, so it is counted like any other dictionary.

event_name: DictColumn

Set only on OTel Events, and enumerable by definition — an event name names a schema, so a producer minting a new one per record is already wrong.

body: StringBuilder

body_ser: BinaryBuilder

trace_id: FixedSizeBinaryBuilder

span_id: FixedSizeBinaryBuilder

flags: UInt32Builder

dropped: UInt32Builder

resource_id: UInt16Builder

scope_id: UInt16Builder

log_attrs: AttrsBuilder

rs: ResourceScope

next_id: u32

min_ts: i64

max_ts: i64

Implementations

impl LogsBuilder

pub fn new() -> Self

pub fn num_rows(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn approx_bytes(&self) -> usize

Rough resident cost of the accumulated builders. Used by the flusher to decide when to seal, so that block size is bounded by bytes rather than by row count (rows vary by three orders of magnitude in width).

The variable-width heaps are measured rather than estimated. Counting only fixed-width columns makes a 32 KB log body weigh the same as a 20-byte one, which is how a 32 MB target seals a multi-gigabyte block on a GenAI workload — and resident footprint is one of the four axes.

pub fn has_headroom_for(&self, req: &ExportLogsServiceRequest) -> bool

Whether req is guaranteed to fit without overflowing a UInt16 dictionary or id space.

Deliberately conservative — it assumes every key in the request is new — because the alternative is discovering the overflow halfway through an append, and an Arrow builder cannot be rolled back. The flusher seals when this returns false and puts the request in the next block, so overflow costs a slightly small block and never costs the caller their data.

pub fn append_request( &mut self, req: &ExportLogsServiceRequest, ) -> Result<usize>

Absorb one OTLP export request. Returns the number of log records added.

pub fn finish(&mut self) -> Result<Sealed>

Seal the accumulated rows into a block and reset for the next one.

The reset happens on the error path too. seal calls finish on each column builder as it goes, so a failure part way through leaves this one holding columns of unequal length; reusing it would make every subsequent seal fail identically and the node would reject exports until restarted.

fn seal(&self, sidecars: Sidecars) -> Result<Sealed>

Trait Implementations

impl Default for LogsBuilder

fn default() -> Self

Returns the “default value” for a type.

impl SignalBuilder for LogsBuilder

const SIGNAL: &'static str = "logs"

Directory component under the data dir. Also the block name prefix, so changing it is an on-disk format change.

type Request = ExportLogsServiceRequest

The decoded OTLP export request this signal accepts.

fn has_headroom_for(&self, req: &Self::Request) -> bool

Whether req is guaranteed to fit without overflowing a UInt16 dictionary or id space.

fn append_request(&mut self, req: &Self::Request) -> Result<usize>

Absorb one export request, returning the number of root-table rows added.

fn approx_bytes(&self) -> usize

Rough resident cost, with variable-width heaps measured rather than estimated from row counts — a 32 KB GenAI prompt must not weigh the same as a 20-byte one.

fn is_empty(&self) -> bool

fn finish(&mut self) -> Result<Sealed>

Seal and reset. After this returns, self is a fresh builder — including on the error path, where the caller has no way to know how far through the column-by-column finish it got.

fn snapshot(&self) -> Result<Sealed>

Materialise the rows accumulated so far without resetting, for Open. Sidecar-free; see Sealed::with.