Trace IDs & Distributed Tracing

from langfuse.decorators import langfuse_context, observe
import uuid
 
@observe()
def process_user_request(user_id, request_data, **kwargs):
    # Function logic here
    pass
 
def main():
    # Custom ID for tracking
    custom_observation_id = "custom-" + str(uuid.uuid4())
 
    # Pass id as kwarg
    process_user_request(
        user_id=user_id,
        request_data=request_data,
        langfuse_observation_id=custom_observation_id,
    )
 
# Get current trace ID from context
trace_id = langfuse_context.get_current_trace_id()
observation_id = langfuse_context.get_current_observation_id()

from langfuse import Langfuse
 
# Set custom trace ID during creation
trace = langfuse.trace(
    id="my-custom-trace-id",
    name="Rap Battle",
)

import { Langfuse } from "langfuse";
import { v4 as uuidv4 } from "uuid";
 
const langfuse = new Langfuse();
 
// Create trace with custom ID
const traceId = uuidv4();
const trace = langfuse.trace({
  id: traceId,
  name: "chat-app-session",
  userId: "user_123456789",
  metadata: { user: "[email protected]" },
  tags: ["production"],
});
 
// Create observations with custom IDs
const span = trace.span({
  id: "custom-span-id",
  name: "chat-interaction",
});
 
const generation = trace.generation({
  id: "custom-generation-id",
  name: "chat-completion",
});

from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode
 
tracer = trace.get_tracer(__name__)
 
with tracer.start_as_current_span("my-operation") as span:
    # Get the trace ID
    trace_id = format(span.get_span_context().trace_id, "032x")
 
    # Set custom attributes
    span.set_attribute("custom.trace_id", trace_id)

from langfuse.openai import openai
 
# Set trace_id directly in the completion call
completion = openai.chat.completions.create(
    name="test-chat",
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a calculator."},
        {"role": "user", "content": "1 + 1 = "}
    ],
    trace_id="my-custom-trace-id"  # Set your custom trace ID
)

from langfuse.decorators import langfuse_context, observe
from langfuse.openai import openai
 
@observe()
def calculate_sum(a: int, b: int, **kwargs):
    # Get the current trace ID if needed
    trace_id = langfuse_context.get_current_trace_id()
 
    completion = openai.chat.completions.create(
        name="calculator",
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a calculator. Only output the numeric result."},
            {"role": "user", "content": f"{a} + {b} = "}
        ]
    )
 
    # The completion will automatically be added to the current trace
    return completion.choices[0].message.content, trace_id
 
# Use with custom trace ID
result, trace_id = calculate_sum(5, 3, langfuse_observation_id="my-custom-trace-id")

import OpenAI from "openai";
import { observeOpenAI } from "langfuse";
 
// Create a trace with custom ID
const trace = langfuse.trace({
  id: "custom-trace-id",
  name: "openai-chat",
});
 
const openai = observeOpenAI(new OpenAI(), {
  parent: trace, // Link OpenAI calls to the trace
});
 
const completion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{ role: "user", content: "Hello!" }],
});

from langfuse.callback import CallbackHandler
import uuid
 
predefined_run_id = str(uuid.uuid4())
 
langfuse_handler = CallbackHandler()
 
# Pass run_id to the chain invocation
chain.invoke(
    {"input": "test"},
    config={
        "callbacks": [langfuse_handler],
        "run_id": predefined_run_id,  # This becomes the trace ID
    },
)

from langfuse.decorators import langfuse_context, observe
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser
 
prompt = ChatPromptTemplate.from_template("what is the city {person} is from?")
model = ChatOpenAI()
chain = prompt | model | StrOutputParser()
 
@observe()
def get_person_city(person: str, **kwargs):
    # Get the Langchain handler from the current context
    langfuse_handler = langfuse_context.get_current_langchain_handler()
 
    # The handler is automatically scoped to the current trace
    response = chain.invoke(
        {"person": person},
        config={"callbacks": [langfuse_handler]}
    )
 
    # Get trace ID if needed
    trace_id = langfuse_context.get_current_trace_id()
    return response, trace_id
 
# Use with custom trace ID
result, trace_id = get_person_city(
    "Einstein",
    langfuse_observation_id="my-custom-trace-id"
)

import { CallbackHandler } from "langfuse-langchain";
 
// Create a trace with custom ID
const trace = langfuse.trace({ id: "special-id" });
 
// CallbackHandler will use the trace with the specified ID
const langfuseHandler = new CallbackHandler({ root: trace });
 
// Use the handler in your chain
const chain = new LLMChain({
  llm: model,
  prompt,
  callbacks: [langfuseHandler],
});

from litellm import completion
 
# Set custom trace ID and other parameters
response = completion(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "user", "content": "Hi 👋"}
  ],
  metadata={
      "generation_name": "test-generation",
      "generation_id": "gen-id",
      "trace_id": "trace-id",
      "trace_user_id": "user-id",
      "session_id": "session-id",
      "tags": ["tag1", "tag2"]
  },
)