Instrumentation

from langfuse import observe
 
@observe()
def my_data_processing_function(data, parameter):
    return {"processed_data": data, "status": "ok"}
 
@observe(name="llm-call", as_type="generation")
async def my_async_llm_call(prompt_text):
    return "LLM response"

import { observe, updateActiveObservation } from "@langfuse/tracing";
 
async function fetchData(source: string) {
  updateActiveObservation({ metadata: { source: "API" } });
  return { data: `some data from ${source}` };
}
 
const tracedFetchData = observe(fetchData, {});
 
const result = await tracedFetchData("API");

from langfuse import get_client, propagate_attributes
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(
    as_type="span",
    name="user-request-pipeline",
    input={"user_query": "Tell me a joke"},
) as root_span:
    with propagate_attributes(user_id="user_123", session_id="session_abc"):
        with langfuse.start_as_current_observation(
            as_type="generation",
            name="joke-generation",
            model="gpt-4o",
        ) as generation:
            generation.update(output="Why did the span cross the road?")
 
    root_span.update(output={"final_joke": "..."})

import { startActiveObservation, startObservation } from "@langfuse/tracing";
 
await startActiveObservation("user-request", async (span) => {
  span.update({ input: { query: "Capital of France?" } });
 
  const generation = startObservation(
    "llm-call",
    { model: "gpt-4", input: [{ role: "user", content: "Capital of France?" }] },
    { asType: "generation" }
  );
  generation.update({ output: { content: "Paris." } }).end();
 
  span.update({ output: "Answered." });
});

from langfuse import get_client
 
langfuse = get_client()
 
span = langfuse.start_span(name="manual-span")
span.update(input="Data for side task")
child = span.start_span(name="child-span")
child.end()
span.end()

import { startObservation } from "@langfuse/tracing";
 
const span = startObservation("user-request", {
  input: { query: "Capital of France?" },
});
 
const toolCall = span.startObservation("fetch-weather", { input: { city: "Paris" } });
await new Promise((resolve) => setTimeout(resolve, 100));
toolCall.update({ output: { temperature: "15°C" } }).end();
 
const generation = span.startObservation(
  "llm-call",
  { model: "gpt-4", input: [{ role: "user", content: "Capital of France?" }] },
  { asType: "generation" }
);
generation.update({ output: { content: "Paris." } }).end();
 
span.update({ output: "Done." }).end();

from langfuse import get_client
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(as_type="generation", name="llm-call") as gen:
    gen.update(
        input={"prompt": "Why is the sky blue?"},
        output="Rayleigh scattering",
        usage_details={"input_tokens": 5, "output_tokens": 50},
    )
 
with langfuse.start_as_current_observation(as_type="span", name="data-processing"):
    langfuse.update_current_span(metadata={"step1_complete": True})

import { startActiveObservation, updateActiveTrace } from "@langfuse/tracing";
 
await startActiveObservation("user-request", async (span) => {
  span.update({ input: { path: "/api/process" } });
 
  await new Promise((resolve) => setTimeout(resolve, 50));
  const user = { id: "user-5678", name: "Jane Doe" };
  updateActiveTrace({
    userId: user.id,
    metadata: { userName: user.name },
  });
 
  span.update({ output: { status: "success" } }).end();
});

from langfuse import get_client, propagate_attributes
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(as_type="span", name="user-workflow"):
    with propagate_attributes(
        user_id="user_123",
        session_id="session_abc",
        metadata={"experiment": "variant_a"},
        version="1.0",
    ):
        with langfuse.start_as_current_observation(as_type="generation", name="llm-call"):
            pass

import { startActiveObservation, propagateAttributes, startObservation } from "@langfuse/tracing";
 
await startActiveObservation("user-workflow", async () => {
  await propagateAttributes(
    {
      userId: "user_123",
      sessionId: "session_abc",
      metadata: { experiment: "variant_a", env: "prod" },
      version: "1.0",
    },
    async () => {
      const generation = startObservation("llm-call", { model: "gpt-4" }, { asType: "generation" });
      generation.end();
    }
  );
});

from langfuse import get_client, propagate_attributes
import requests
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(as_type="span", name="api-request"):
    with propagate_attributes(
        user_id="user_123",
        session_id="session_abc",
        as_baggage=True,
    ):
        requests.get("https://service-b.example.com/api")

import { propagateAttributes, startActiveObservation } from "@langfuse/tracing";
 
await startActiveObservation("api-request", async () => {
  await propagateAttributes(
    {
      userId: "user_123",
      sessionId: "session_abc",
      asBaggage: true,
    },
    async () => {
      await fetch("https://service-b.example.com/api");
    }
  );
});

from langfuse import get_client
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(as_type="span", name="complex-pipeline") as root_span:
    root_span.update(input="Step 1 data", output="Step 1 result")
    root_span.update_trace(
        input={"original_query": "User question"},
        output={"final_answer": "Complete response", "confidence": 0.95},
    )

from langfuse import observe, get_client
 
langfuse = get_client()
 
@observe()
def process_user_query(user_question: str):
    answer = call_llm(user_question)
    langfuse.update_current_trace(
        input={"question": user_question},
        output={"answer": answer},
    )
    return answer

import { startObservation } from "@langfuse/tracing";
 
const rootSpan = startObservation("data-processing");
 
// ... some initial steps ...
 
const userId = "user-123";
const sessionId = "session-abc";
rootSpan.updateTrace({
  userId: userId,
  sessionId: sessionId,
  tags: ["authenticated-user"],
  metadata: { plan: "premium" },
});
 
const generation = rootSpan.startObservation(
  "llm-call",
  {},
  { asType: "generation" }
);
 
generation.end();
 
rootSpan.end();

from langfuse import get_client, Langfuse
 
langfuse = get_client()
 
with langfuse.start_as_current_observation(as_type="span", name="my-op") as current_op:
    trace_id = langfuse.get_current_trace_id()
    observation_id = langfuse.get_current_observation_id()
    print(trace_id, observation_id)
 
external_request_id = "req_12345"
deterministic_trace_id = Langfuse.create_trace_id(seed=external_request_id)

import { createTraceId, startObservation } from "@langfuse/tracing";
 
const externalId = "support-ticket-54321";
 
const langfuseTraceId = await createTraceId(externalId);
 
const rootSpan = startObservation(
  "process-ticket",
  {},
  {
    parentSpanContext: {
      traceId: langfuseTraceId,
      spanId: "0123456789abcdef",
      traceFlags: 1,
    },
  }
);

import { startObservation, getActiveTraceId } from "@langfuse/tracing";
 
await startObservation("run", async (span) => {
  const traceId = getActiveTraceId();
  console.log(`Current trace ID: ${traceId}`);
});

from langfuse import get_client
 
langfuse = get_client()
 
existing_trace_id = "abcdef1234567890abcdef1234567890"
existing_parent_span_id = "fedcba0987654321"
 
with langfuse.start_as_current_observation(
    as_type="span",
    name="process-downstream-task",
    trace_context={
        "trace_id": existing_trace_id,
        "parent_span_id": existing_parent_span_id,
    },
):
    pass

import { startObservation } from "@langfuse/tracing";
 
const span = startObservation(
  "downstream-task",
  {},
  {
    parentSpanContext: {
      traceId: "abcdef1234567890abcdef1234567890",
      spanId: "fedcba0987654321",
      traceFlags: 1,
    },
  }
);
 
span.end();

from langfuse import get_client
 
langfuse = get_client()
# ... create traces ...
langfuse.flush()
langfuse.shutdown()

import { NodeSDK } from "@opentelemetry/sdk-node";
import { LangfuseSpanProcessor } from "@langfuse/otel";
 
export const langfuseSpanProcessor = new LangfuseSpanProcessor({
  exportMode: "immediate",
});
 
const sdk = new NodeSDK({
  spanProcessors: [langfuseSpanProcessor],
});
 
sdk.start();

import { langfuseSpanProcessor } from "./instrumentation";
 
export async function handler(event, context) {
  // ... logic ...
  await langfuseSpanProcessor.forceFlush();
}