Tracelane Python SDK — tracelane package

Install

pip install tracelane

All framework adapters ship in the package. Nothing is patched on import — instrumentation is explicit: call init(), then either auto_instrument() (best-effort for a small set of libraries) or the individual instrument_* functions for exactly what you want traced.

Initialize

Call tracelane.init(...) once at application start — before the code you want traced runs. endpoint and api_key are required (there is no env-var auto-read).

from tracelane import init

init(
    endpoint="https://gateway.tracelane.dev",  # Tracelane Cloud
    api_key="tlane_...",                       # needs the `ingest` scope
    service_name="my-agent",                   # shows in trace viewer
)

Parameter	Required	Default	Description
`endpoint`	yes	—	OTLP HTTP endpoint. `https://gateway.tracelane.dev` for Cloud, or a receiver you run. Spans POST to `${endpoint}/v1/traces`.
`api_key`	yes	—	Your `tlane_*` key. Sent as the `x-tracelane-api-key` header.
`service_name`	no	`"unknown-service"`	Service name on spans
`sample_rate`	no	`1.0`	Fraction of traces to capture (0.0–1.0; tail sampler decides)
`auto_instrument`	no	`False`	If `True`, run `auto_instrument()` after init (see below)

endpoint is any OTLP HTTP receiver you can reach — Tracelane Cloud’s gateway (https://gateway.tracelane.dev), a self-hosted Tracelane ingest, or a local collector such as http://localhost:4318.

Your key needs the ingest scope. Keys minted before scopes existed carry the full API surface and work as-is. A key you scoped to chat and read does not — the gateway answers 403 insufficient_scope and names ingest in the body. Tick Ingest in Settings → API Keys; it is on by default for new keys.

Instrument what you want traced

Constructing a client does not patch it. After init(), you have two options.

Option A — `auto_instrument()` (best-effort, 5 libraries)

from tracelane import init, auto_instrument

init(endpoint="http://localhost:4318", api_key="tlane_...")
auto_instrument()

auto_instrument() attempts anthropic, openai, litellm, langgraph, and claude_code, printing each outcome to stderr. Anthropic/OpenAI only wrap a new default client; wrap your own clients explicitly. Install tracelane[langgraph] to capture graph and child runs via OpenInference’s LangChain callbacks and your existing exporter. Inputs/outputs are redacted; custom metadata may still be captured. Existing LangChain instrumentation keeps its configuration. If the integration is unavailable, call instrument_langgraph(graph) after compilation for graph-level spans. See LangGraph for a runnable example. All other adapters need explicit calls.

Option B — explicit `instrument_*` calls

There are 28 instrument_* functions. Each takes the object you constructed and patches it in place. Call after init().

Adapters

LLM providers

from tracelane import (
    init, instrument_anthropic, instrument_openai,
    instrument_bedrock, instrument_vertexai, instrument_azure_openai,
)

init(endpoint="http://localhost:4318", api_key="tlane_...")

# Anthropic — claude-* models
from anthropic import Anthropic
client = Anthropic()
instrument_anthropic(client)   # now messages.create() emits spans
client.messages.create(model="claude-sonnet-4-6", messages=[...], max_tokens=1024)

# OpenAI — gpt-*, o1*, o3*, embeddings
from openai import OpenAI
oai = OpenAI()
instrument_openai(oai)
oai.chat.completions.create(model="gpt-4o", messages=[...])

# AWS Bedrock
import boto3
bedrock = boto3.client("bedrock-runtime")
instrument_bedrock(bedrock)    # invoke_model calls captured

# Google Vertex AI
from vertexai.generative_models import GenerativeModel
model = GenerativeModel("gemini-2.0-flash")
instrument_vertexai(model)

# Azure OpenAI
from openai import AzureOpenAI
az = AzureOpenAI()
instrument_azure_openai(az)

Agent frameworks

Construct the chain/graph/agent, then instrument it — none of this is instrumented for you.

from tracelane import (
    instrument_langchain, instrument_langgraph, instrument_llamaindex,
    instrument_crewai, instrument_autogen, instrument_pydantic_ai,
    instrument_openai_agents, instrument_magentic_one, instrument_smolagents,
    instrument_haystack,
)

# LangChain
from langchain_anthropic import ChatAnthropic
model = ChatAnthropic(model="claude-sonnet-4-6")
instrument_langchain(model)

# LangGraph
from langgraph.graph import StateGraph
graph = build_graph().compile()
instrument_langgraph(graph)      # manual fallback: graph-level spans

# LlamaIndex
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(docs)
instrument_llamaindex(index)

# CrewAI
from crewai import Agent
agent = Agent(role="researcher", goal="...", backstory="...")
instrument_crewai(agent)

# AutoGen
import autogen
assistant = autogen.AssistantAgent(name="assistant")
instrument_autogen(assistant)

# Pydantic AI
from pydantic_ai import Agent
agent = Agent("anthropic:claude-sonnet-4-6")
instrument_pydantic_ai(agent)

# OpenAI Agents SDK
from agents import Runner
instrument_openai_agents(Runner)  # wrap the Runner class

# Magentic-One
from autogen_ext.agents.magentic_one import MagenticOne
m1 = MagenticOne(client=oai_client)
instrument_magentic_one(m1)

# smolagents (HuggingFace)
from smolagents import CodeAgent, HfApiModel
sa = CodeAgent(tools=[], model=HfApiModel())
instrument_smolagents(sa)

# Haystack
from haystack import Pipeline
pipe = Pipeline()
instrument_haystack(pipe)

Memory & vector stores

from tracelane import instrument_pinecone, instrument_qdrant, instrument_mem0

# Pinecone
from pinecone import Pinecone
index = Pinecone(api_key="...").Index("my-index")
instrument_pinecone(index)    # upsert, query, fetch, delete captured

# Qdrant
from qdrant_client import QdrantClient
qc = QdrantClient(":memory:")
instrument_qdrant(qc)         # search, upsert, delete captured

# Mem0 (memory layer)
from mem0 import Memory
mem = Memory()
instrument_mem0(mem)          # add, search, get captured with memory IDs

Tools & browser

from tracelane import (
    instrument_browserbase, instrument_e2b, instrument_firecrawl,
    instrument_composio, instrument_mcp, instrument_claude_code, instrument_letta,
)

# Browserbase — managed browser sessions
from browserbase import Browserbase
bb = Browserbase(api_key="...")
instrument_browserbase(bb)

# E2B — code execution sandbox
from e2b import Sandbox
instrument_e2b(Sandbox)       # wrap the Sandbox class

# Firecrawl — web scraping
from firecrawl import FirecrawlApp
app = FirecrawlApp(api_key="...")
instrument_firecrawl(app)     # scrape, crawl, search captured

# Composio — tool integrations
from composio_langchain import ComposioToolSet
toolset = ComposioToolSet()
instrument_composio(toolset)

# MCP — Model Context Protocol
from mcp import ClientSession
# after you have a ClientSession `session`:
instrument_mcp(session)       # tool_call and tool_result messages traced

# Claude Code (SDK mode) — module-level, no argument
instrument_claude_code()

# Letta (MemGPT)
from letta import create_client
letta = create_client()
instrument_letta(letta)

Custom spans

The SDK sets up a standard OpenTelemetry tracer provider, so custom spans use the OpenTelemetry Python API directly — the SDK ships no custom-span wrapper:

from opentelemetry import trace

tracer = trace.get_tracer("my-agent")
with tracer.start_as_current_span("retrieval") as span:
    span.set_attribute("retrieval.top_k", 10)
    span.set_attribute("retrieval.index", "prod-v3")
    results = vector_store.search(query, top_k=10)

Sampling

# Trace 10% of requests in production, 100% in dev
import os
from tracelane import init

init(
    endpoint="http://localhost:4318",
    api_key="tlane_...",
    sample_rate=0.1 if os.getenv("ENV") == "production" else 1.0,
)

Shutdown

# Flush pending spans and shut down the OTel SDK — call at process exit
from tracelane import shutdown

shutdown()

Testing

Nothing is patched until you call init() and instrument_*, so a test that skips them emits no spans — no disable flag needed. To assert on emitted spans, register your own provider with a standard in-memory exporter before instrumenting, then read the finished spans:

from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry import trace

exporter = InMemorySpanExporter()
provider = TracerProvider()
provider.add_span_processor(SimpleSpanProcessor(exporter))
trace.set_tracer_provider(provider)

# ... construct + instrument_anthropic(client), run the code under test ...

spans = exporter.get_finished_spans()
assert len(spans) == 3

Get started

SDKs

Integrations

Concepts

Features

Tools

Audit & compliance

Operations

Migrations

Comparisons

Tracelane Python SDK — tracelane package

Install

Initialize

Instrument what you want traced

Option A — `auto_instrument()` (best-effort, 5 libraries)

Option B — explicit `instrument_*` calls

Adapters

LLM providers

Agent frameworks

Memory & vector stores

Tools & browser

Custom spans

Sampling

Shutdown

Testing

​Install

​Initialize

​Instrument what you want traced

​Option A — auto_instrument() (best-effort, 5 libraries)

​Option B — explicit instrument_* calls

​Adapters

​LLM providers

​Agent frameworks

​Memory & vector stores

​Tools & browser

​Custom spans

​Sampling

​Shutdown

​Testing

​Related

Install

Initialize

Instrument what you want traced

Option A — `auto_instrument()` (best-effort, 5 libraries)

Option B — explicit `instrument_*` calls

Adapters

LLM providers

Agent frameworks

Memory & vector stores

Tools & browser

Custom spans

Sampling

Shutdown

Testing

Related