Library-async-logger-bind

Attach shared structured fields to a LibraryAsyncLogger[S] through the bind(...) alias. This is behaviorally identical to with_context_fields(...) and exists as a shorter name for common library-facing async context binding.

Interface

pub fn[S] LibraryAsyncLogger::bind(
  self : LibraryAsyncLogger[S],
  fields : Array[@bitlogger.Field],
) -> LibraryAsyncLogger[S] {

input

• self : LibraryAsyncLogger[S] - Base facade that should gain shared fields.
• fields : Array[@bitlogger.Field] - Structured fields attached to every emitted record.

output

• LibraryAsyncLogger[S] - New library-facing async wrapper that carries the shared field set.

Explanation

Detailed rules explaining key parameters and behaviors

• bind(...) delegates directly to with_context_fields(...).
• That means the provided fields array replaces the previously stored shared field set on the wrapped async logger.
• Shared fields are then prepended to every later log call emitted through the returned facade.
• Sink type, queue state, async config, and failure/lifecycle state remain the same because the method only rewraps the updated async logger value.
• Async state helpers remain hidden behind the narrower facade after rewrapping; use to_async_logger() if later code needs them.
• The original facade value is not mutated; a wrapped facade is returned.
• This alias is useful when you prefer shorter chaining syntax in library async code.

How to Use

Here are some specific examples provided.

When Bind Shared Package Context For Async Writes

When a library async logger should carry stable metadata through a flow:

let request_logger = LibraryAsyncLogger::new(@bitlogger.console_sink())
  .with_target("sdk")
  .bind([@bitlogger.field("request_id", "req-42")])

In this example, subsequent async writes automatically include request_id.

When Prefer Shorter Async Chaining Syntax

When a context-bound child async facade should stay readable:

let worker = LibraryAsyncLogger::new(@bitlogger.console_sink(), target="app")
  .child("worker")
  .bind([@bitlogger.field("component", "worker")])

In this example, bind(...) communicates intent without changing underlying behavior.

And because it is only an alias, the resulting facade behaves the same as calling with_context_fields(...) directly.

Error Case

e.g.:

• If fields is empty, the returned facade remains valid and simply stores an empty shared field set.

• If duplicate field keys are bound, all copies are preserved for downstream formatting or inspection.

• If callers want event-specific fields without replacing the shared bound set, they should pass those through log(..., fields=...) on the returned facade.

Notes

1. Use bind(...) and with_context_fields(...) interchangeably; choose the one that reads better in context.

2. This alias exists for ergonomics, not for different semantics.

3. Use with_context_fields(...) when the longer name makes the shared-field replacement behavior clearer at the call site.