Auto-Instrumentation

Zero-config tracing for LangChain, LangGraph, Microsoft Agent Framework, Pydantic AI, Google ADK, and Haystack applications. It traces LLM calls, tool invocations, retrieval, and chain executions without modifying your code.

API at a glance

The full auto-instrumentation surface lives in rhesis.sdk.telemetry:

from rhesis.sdk.telemetry import auto_instrument, disable_auto_instrument

auto_instrument()                              # auto-detect installed frameworks
auto_instrument("langchain")                   # explicit single framework
auto_instrument("langchain", "langgraph")      # explicit multiple frameworks
auto_instrument("agent_framework")             # Microsoft Agent Framework (alias: "maf")
auto_instrument("pydantic_ai")                 # Pydantic AI
auto_instrument("google_adk")                  # Google ADK (alias: "adk")
auto_instrument("haystack")                    # Haystack
disable_auto_instrument()                      # turn everything off

The function returns the list of frameworks it actually instrumented, so you can log it in your bootstrap:

enabled = auto_instrument()
print(f"Tracing enabled for: {enabled}")  # e.g. ['langchain', 'langgraph', 'agent_framework', 'pydantic_ai', 'google_adk']

LangChain

Installation

pip install "rhesis-sdk[langchain]>=0.6.0"

Usage

from rhesis.sdk import RhesisClient
from rhesis.sdk.telemetry import auto_instrument
from langchain_google_genai import ChatGoogleGenerativeAI

# Initialize Rhesis
client = RhesisClient(
    api_key="your-api-key",
    project_id="your-project-id",
)

# Enable auto-instrumentation
auto_instrument()

# Use LangChain normally - all calls are traced
llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")
response = llm.invoke("Explain quantum computing")

What Gets Traced

• LLM invocations with token counts, one ai.prompt event per message sent
• Tool calls with inputs and outputs
• Retriever calls, with the query, the documents returned and how many
• Streaming responses
• Errors and exceptions

The steps of an LCEL pipeline are not spans of their own — a prompt | llm | parser chain reports three of them and none is a unit of work. The LLM call inside it is traced.

LCEL Chain Example

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You explain concepts in a {style} way."),
    ("user", "Explain {topic}"),
])

chain = prompt | llm

# Automatically traced
result = chain.invoke({"topic": "Machine Learning", "style": "simple"})

Tools Example

from langchain_core.tools import tool

@tool
def calculator(expression: str) -> str:
    """Evaluate a mathematical expression."""
    return str(eval(expression))

# Tool calls are automatically traced
result = calculator.invoke({"expression": "2 + 2 * 3"})

Under the hood the integration registers a callback handler globally and patches BaseTool.invoke / BaseTool.ainvoke, so tool spans fire even when the framework’s normal callback plumbing is bypassed by user code.

LangGraph

Installation

pip install "rhesis-sdk[langgraph]>=0.6.0"

Usage

from rhesis.sdk import RhesisClient
from rhesis.sdk.telemetry import auto_instrument
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict, Annotated
from langgraph.graph.message import add_messages

client = RhesisClient(
    api_key="your-api-key",
    project_id="your-project-id",
)

# Enable LangGraph instrumentation
auto_instrument("langgraph")

class State(TypedDict):
    messages: Annotated[list, add_messages]

def researcher(state: State):
    response = llm.invoke(state["messages"][-1].content)
    return {"messages": [response]}

def analyst(state: State):
    response = llm.invoke(f"Analyze: {state['messages'][-1].content}")
    return {"messages": [response]}

# Build graph
workflow = StateGraph(State)
workflow.add_node("researcher", researcher)
workflow.add_node("analyst", analyst)
workflow.add_edge(START, "researcher")
workflow.add_edge("researcher", "analyst")
workflow.add_edge("analyst", END)

app = workflow.compile()

# All nodes and LLM calls are traced
result = app.invoke({"messages": ["What are the benefits of LangGraph?"]})

How LangChain and LangGraph share a callback

LangGraph runs on top of LangChain’s callback system. To avoid emitting duplicate spans when both are present, the LangGraph integration reuses the singleton LangChain callback instead of creating its own. That means:

• auto_instrument("langgraph") already covers LangChain chains, LCEL pipelines, tools, and LLM calls invoked from inside graph nodes — you do not need to add "langchain" explicitly.
• Calling auto_instrument("langchain", "langgraph") is safe and idempotent: the second integration finds the callback already registered and only adds the graph-method patches on top.
• The integration also patches CompiledStateGraph.invoke / ainvoke / stream / astream, so every graph entry point injects the callback automatically — no need to thread it through config={"callbacks": [...]} yourself.

Trace Output

Each node in the graph produces spans following semantic conventions. The graph itself gets an ai.agent.invoke span and every node gets one beneath it, whatever the node is called, with its LLM, tool and retrieval spans nested inside. One graph run is one trace.

Spans include attributes for model name, provider, token counts (input/output), and tool names.

Delegation between agents is traced separately as ai.agent.handoff — see Multi-Agent Tracing. Grouping the turns of one session into a conversation is covered in Conversation Tracing.

Combining with Decorators

Auto-instrumentation works alongside @observe and @endpoint:

from rhesis.sdk import RhesisClient, endpoint
from rhesis.sdk.telemetry import auto_instrument

client = RhesisClient(...)
auto_instrument()

@endpoint()
def chat_handler(input: str) -> dict:
    # This function traced by @endpoint
    # Internal LangChain calls traced by auto-instrumentation
    chain = prompt | llm
    return {"output": chain.invoke({"message": input})}

Manual callback injection (advanced)

In nearly all cases, auto_instrument() is enough — the SDK patches the framework entry points and traces fire transparently. For the rare situation where you build a custom wrapper around CompiledStateGraph that bypasses the patched methods, you can fetch the active callback and pass it through yourself:

from rhesis.sdk.telemetry import auto_instrument
from rhesis.sdk.telemetry.integrations.langchain import get_callback

auto_instrument("langgraph")

callback = get_callback()
config = {"callbacks": [callback]} if callback else {}
result = my_custom_invoke(graph, state, config=config)

get_callback() returns None if LangChain instrumentation has not been enabled in this process.

Disabling

To turn off every previously-enabled framework — for example before reconfiguring tracing in a test fixture — call disable_auto_instrument():

from rhesis.sdk.telemetry import disable_auto_instrument

disable_auto_instrument()

Supported Frameworks

Microsoft Agent Framework, Google ADK and Haystack each have their own dedicated guide — see Microsoft Agent Framework, Google ADK and Haystack for installation, handoff tracing, and content-capture options. For Pydantic AI, call auto_instrument("pydantic_ai") after creating RhesisClient.

Haystack needs one extra step: HAYSTACK_CONTENT_TRACING_ENABLED must be true before haystack is imported, or its spans carry no prompts or completions.

For frameworks not in the auto-instrument list, wrap the functions, tools, or agents you want to trace with @observe.llm, @observe.tool, @observe.retrieval, etc. Without decorators only top-level inputs and outputs are captured.

To add a new framework to the auto-instrument list, see Contributing: SDK Integrations.