View Source LangChain.Telemetry (LangChain v0.3.3)

Telemetry events for LangChain.

This module defines telemetry events that other applications can attach to. It provides a standardized way to emit events for various operations in the LangChain library without implementing tracing functionality.

Event Naming

Events follow the convention: [:langchain, component, operation, stage]

Core Events

  • [:langchain, :llm, :call, :start] - Emitted when an LLM call starts
  • [:langchain, :llm, :call, :stop] - Emitted when an LLM call completes
  • [:langchain, :llm, :call, :exception] - Emitted when an LLM call raises an exception
  • [:langchain, :llm, :prompt] - Emitted when a prompt is sent to an LLM
  • [:langchain, :llm, :response] - Emitted when a response is received from an LLM
  • [:langchain, :llm, :response, :non_streaming] - Emitted when a non-streaming response is received from an LLM
  • [:langchain, :llm, :response, :streaming] - Emitted when a streaming response is received from an LLM
  • [:langchain, :chain, :execute, :start] - Emitted when a chain execution starts
  • [:langchain, :chain, :execute, :stop] - Emitted when a chain execution completes
  • [:langchain, :chain, :execute, :exception] - Emitted when a chain execution raises an exception
  • [:langchain, :message, :process, :start] - Emitted when message processing starts
  • [:langchain, :message, :process, :stop] - Emitted when message processing completes
  • [:langchain, :message, :process, :exception] - Emitted when message processing raises an exception
  • [:langchain, :tool, :call, :start] - Emitted when a tool call starts
  • [:langchain, :tool, :call, :stop] - Emitted when a tool call completes
  • [:langchain, :tool, :call, :exception] - Emitted when a tool call raises an exception

Usage

To attach to these events in your application:

:telemetry.attach(
  "my-handler-id",
  [:langchain, :llm, :call, :stop],
  &MyApp.handle_llm_call/4,
  nil
)

def handle_llm_call(_event_name, measurements, metadata, _config) do
  # Process the event
  IO.inspect(measurements)
  IO.inspect(metadata)
end

Summary

Functions

Emits a chain execution start event.

Emits a telemetry event with the given name, measurements, and metadata.

Emits an LLM call start event.

Emits an LLM prompt event.

Emits an LLM response event.

Emits a memory read start event.

Emits a memory write start event.

Emits a message processing start event.

Emits a retriever get relevant documents start event.

Wraps a function call with start and stop telemetry events.

Emits a start event and returns a function to emit the corresponding stop event.

Emits a tool call event.

Emits a tool call start event.

Functions

Link to this function

chain_execute_start(metadata)

View Source
@spec chain_execute_start(map()) :: (map() -> :ok)

Emits a chain execution start event.

Link to this function

emit_event(event_name, measurements, metadata)

View Source
@spec emit_event([atom()], map(), map()) :: :ok

Emits a telemetry event with the given name, measurements, and metadata.

Parameters

  • event_name - The name of the event as a list of atoms
  • measurements - A map of measurements for the event
  • metadata - A map of metadata for the event

Examples

iex> LangChain.Telemetry.emit_event([:langchain, :llm, :call, :start], %{system_time: System.system_time()}, %{model: "gpt-4"})
Link to this function

llm_call_start(metadata)

View Source
@spec llm_call_start(map()) :: (map() -> :ok)

Emits an LLM call start event.

Link to this function

llm_prompt(measurements, metadata)

View Source
@spec llm_prompt(map(), map()) :: :ok

Emits an LLM prompt event.

Link to this function

llm_response(measurements, metadata)

View Source
@spec llm_response(map(), map()) :: :ok

Emits an LLM response event.

Link to this function

memory_read_start(metadata)

View Source
@spec memory_read_start(map()) :: (map() -> :ok)

Emits a memory read start event.

Link to this function

memory_write_start(metadata)

View Source
@spec memory_write_start(map()) :: (map() -> :ok)

Emits a memory write start event.

Link to this function

message_process_start(metadata)

View Source
@spec message_process_start(map()) :: (map() -> :ok)

Emits a message processing start event.

Link to this function

retriever_get_relevant_documents_start(metadata)

View Source
@spec retriever_get_relevant_documents_start(map()) :: (map() -> :ok)

Emits a retriever get relevant documents start event.

Link to this function

span(event_prefix, metadata, fun)

View Source
@spec span([atom()], map(), (-> result)) :: result when result: any()

Wraps a function call with start and stop telemetry events.

Parameters

  • event_prefix - The prefix for the event name as a list of atoms
  • metadata - A map of metadata for the event
  • fun - The function to execute

Returns

The result of the function call.

Examples

iex> LangChain.Telemetry.span([:langchain, :llm, :call], %{model: "gpt-4"}, fn ->
...>   # Call the LLM
...>   {:ok, "response"}
...> end)
Link to this function

start_event(event_prefix, metadata)

View Source
@spec start_event([atom()], map()) :: (map() -> :ok)

Emits a start event and returns a function to emit the corresponding stop event.

This is useful for span-like events where you want to measure the duration of an operation.

Parameters

  • event_prefix - The prefix for the event name as a list of atoms
  • metadata - A map of metadata for the event

Returns

A function that accepts additional metadata to be merged with the original metadata and emits the stop event with the duration measurement.

Examples

iex> stop_fun = LangChain.Telemetry.start_event([:langchain, :llm, :call], %{model: "gpt-4"})
iex> # Do some work
iex> stop_fun.(%{result: "success"})
Link to this function

tool_call(measurements, metadata)

View Source
@spec tool_call(map(), map()) :: :ok

Emits a tool call event.

Link to this function

tool_call_start(metadata)

View Source
@spec tool_call_start(map()) :: (map() -> :ok)

Emits a tool call start event.