Migrate from Langfuse

from langfuse.decorators import observe, langfuse_context
from openai import OpenAI

client = OpenAI()

@observe()
def generate_response(prompt: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Must flush manually
langfuse_context.flush()

from honeyhive import trace, HoneyHiveTracer
from openai import OpenAI
import os

# Initialize once at startup
HoneyHiveTracer.init(
    api_key=os.environ["HH_API_KEY"],
    project=os.environ["HH_PROJECT"]
)

client = OpenAI()

@trace(event_name="generate_response")
def generate_response(prompt: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Traces flush automatically

from langfuse.decorators import observe, langfuse_context

@observe()
def process_document(doc: str):
    langfuse_context.update_current_observation(
        metadata={"doc_length": len(doc)}
    )

    with langfuse_context.observe(name="extract_entities") as span:
        entities = extract(doc)
        span.update(output={"entities": entities})

    with langfuse_context.observe(name="summarize") as span:
        summary = summarize(doc, entities)
        span.update(output={"summary": summary})

    return summary

from honeyhive import trace, enrich_span

@trace(event_name="process_document")
def process_document(doc: str):
    enrich_span(metadata={"doc_length": len(doc)})

    @trace(event_name="extract_entities")
    def _extract():
        entities = extract(doc)
        enrich_span(outputs={"entities": entities})
        return entities

    @trace(event_name="summarize")
    def _summarize(entities):
        summary = summarize(doc, entities)
        enrich_span(outputs={"summary": summary})
        return summary

    entities = _extract()
    return _summarize(entities)

from langfuse import Langfuse
from langfuse.openai import openai  # Patched client

langfuse = Langfuse()

# Must use the patched client
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}],
    name="greeting"  # Langfuse-specific param
)

langfuse.flush()

from honeyhive import HoneyHiveTracer
from openinference.instrumentation.openai import OpenAIInstrumentor
from openai import OpenAI  # Standard, unpatched client
import os

# 1. Initialize HoneyHive
tracer = HoneyHiveTracer.init(
    api_key=os.environ["HH_API_KEY"],
    project=os.environ["HH_PROJECT"]
)

# 2. Attach your chosen instrumentor
OpenAIInstrumentor().instrument(tracer_provider=tracer.provider)

# 3. Use the standard OpenAI client
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}]
)
# All LLM calls are auto-traced

from langfuse import Langfuse

langfuse = Langfuse()

langfuse.score(
    trace_id="...",
    name="quality",
    value=0.8
)

from honeyhive import enrich_span

# Option 1: Client-side enrichment
enrich_span(metrics={"quality": 0.8})

# Option 2: Configure server-side evaluators in the dashboard.
# They run on all traces automatically, no client code needed.