Candil.Telemetry (Candil v3.0.0)

Copy Markdown View Source

Telemetry events emitted by Candil during LLM inference.

All events are prefixed with [:candil, ...] so a single handler can attach to everything Candil does.

Events

  • [:candil, :inference, :start] — a chat/embedding/streaming request begins. Metadata: :model, :provider, :kind (:chat | :embed | :stream), :request_id.
  • [:candil, :inference, :stop] — a request completes successfully. Metadata adds :duration_ms, :tokens_in, :tokens_out.
  • [:candil, :inference, :token] — a streamed token arrives (only fires for chat_stream). Metadata: :request_id, :tokens_so_far.
  • [:candil, :inference, :error] — a request fails. Metadata: :model, :provider, :kind, :request_id, :reason, :duration_ms.
  • [:candil, :cost, :estimate] — a cost estimate was computed. Metadata: :provider, :model, :tokens_in, :tokens_out, :cost_usd.
  • [:candil, :cancellation] — a generation was cancelled. Metadata: :request_id, :reason.

Measurements

Measurements follow the duration_in_native_time convention from :telemetry. To get milliseconds, use System.convert_time_unit(duration, :native, :millisecond).

Example

:telemetry.attach("candil-logger", [:candil, :inference, :stop], fn _name, measurements, meta, _ ->
  Logger.info("inference done in #{measurements.duration_ms}ms")
end, nil)

Summary

Types

event_kind()

@type event_kind() :: :chat | :embed | :stream

Functions

emit_cancellation(request_id, reason \\ :cancelled)

@spec emit_cancellation(String.t(), atom()) :: :ok

Emit a :cancellation event.

emit_cost(provider, model, tokens_in, tokens_out, cost_usd)

@spec emit_cost(atom(), String.t(), non_neg_integer(), non_neg_integer(), float()) ::
  :ok

Emit a :cost event.

emit_error(request_id, kind, duration_native, reason, meta)

@spec emit_error(String.t(), event_kind(), non_neg_integer(), atom(), map()) :: :ok

Emit an :error event.

emit_start(request_id, kind, meta)

@spec emit_start(String.t(), event_kind(), map()) :: :ok

Emit a :start event.

emit_stop(request_id, kind, duration_native, meta \\ [])

@spec emit_stop(String.t(), event_kind(), non_neg_integer(), keyword() | map()) :: :ok

Emit a :stop event with timing data.

emit_token(request_id, tokens_so_far)

@spec emit_token(String.t(), non_neg_integer()) :: :ok

Emit a :token event for streaming responses.