File size: 6,815 Bytes
27f6252 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | """
Langfuse tracing integration for the agentic RAG pipeline.
Provides:
get_langfuse_client() — lazy singleton Langfuse client (self-hosted)
get_langfuse_handler() — LangChain CallbackHandler for LangGraph node tracing
traced_llm_call() — context manager that wraps llm_client.generate()
into a GENERATION observation with token estimates
push_score() — attach eval scores to a trace
Gracefully degrades to no-op if LANGFUSE_ENABLED=false or langfuse not installed.
"""
from __future__ import annotations
import logging
import time
from contextlib import contextmanager
from typing import Any, Optional
from src.agents.agent_config import (
LANGFUSE_ENABLED, LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY,
LANGFUSE_HOST, LANGFUSE_PROMPT_LIMIT,
)
logger = logging.getLogger(__name__)
_langfuse_client: Any = None
_langfuse_handler: Any = None
_langfuse_import_error: Optional[str] = None
def get_langfuse_client():
"""Lazy-singleton Langfuse client. Returns None if disabled or unavailable."""
global _langfuse_client, _langfuse_import_error
if _langfuse_client is not None:
return _langfuse_client
if not LANGFUSE_ENABLED:
return None
if not LANGFUSE_PUBLIC_KEY or not LANGFUSE_SECRET_KEY:
logger.debug("Langfuse keys not set — tracing disabled")
return None
try:
from langfuse import Langfuse
_langfuse_client = Langfuse(
public_key=LANGFUSE_PUBLIC_KEY,
secret_key=LANGFUSE_SECRET_KEY,
host=LANGFUSE_HOST,
)
logger.info("Langfuse client connected (host=%s)", LANGFUSE_HOST)
except ImportError:
_langfuse_import_error = "langfuse package not installed — pip install langfuse"
logger.debug(_langfuse_import_error)
except Exception as e:
_langfuse_import_error = str(e)
logger.warning("Langfuse client init failed: %s", e)
return _langfuse_client
def get_langfuse_handler():
"""Lazy-singleton LangChain CallbackHandler for LangGraph node tracing."""
global _langfuse_handler
if _langfuse_handler is not None:
return _langfuse_handler
client = get_langfuse_client()
if client is None:
return None
try:
from langfuse.langchain import CallbackHandler
_langfuse_handler = CallbackHandler()
logger.debug("Langfuse CallbackHandler created")
except ImportError:
logger.debug("langfuse.langchain.CallbackHandler not available")
except Exception as e:
logger.warning("CallbackHandler creation failed: %s", e)
return _langfuse_handler
class _TracedGeneration:
"""Wraps llm_client.generate() — callable, with token/timing accessors."""
def __init__(self, llm_client: Any, prompt: str, node_name: str, gen_kwargs: dict):
self._llm_client = llm_client
self._prompt = prompt
self._node_name = node_name
self._gen_kwargs = gen_kwargs
self._start_ns: int = 0
self._response: str = ""
def __call__(self) -> str:
self._start_ns = time.perf_counter_ns()
self._response = self._llm_client.generate(self._prompt, **self._gen_kwargs)
return self._response
# ── read-only properties (valid after __call__) ──────────────────────────
@property
def response(self) -> str: return self._response
@property
def elapsed_ms(self) -> float:
if self._start_ns == 0:
return 0.0
return (time.perf_counter_ns() - self._start_ns) / 1e6
@property
def input_tokens(self) -> int:
try:
return self._llm_client.count_tokens(self._prompt)
except Exception:
return len(self._prompt) // 4
@property
def output_tokens(self) -> int:
try:
return self._llm_client.count_tokens(self._response)
except Exception:
return len(self._response) // 4
@property
def model_name(self) -> str:
try:
return self._llm_client.get_model_info().get("model_name", "llm")
except Exception:
return "llm"
@contextmanager
def traced_llm_call(llm_client: Any, prompt: str, node_name: str,
trace_id: str = "", **gen_kwargs):
"""
Context manager wrapping an LLM call for Langfuse tracing.
Usage:
with traced_llm_call(llm_client, prompt, "route",
trace_id=state.get("tracing_trace_id", ""),
max_tokens=200) as gen:
response = gen()
On exit, records input/output, estimated token counts, model, and latency
as a GENERATION observation under the given trace_id.
No-op when LANGFUSE_ENABLED=false, trace_id is empty, or langfuse unavailable.
"""
client = get_langfuse_client()
gen = _TracedGeneration(llm_client, prompt, node_name, gen_kwargs)
yield gen
if client is None or not trace_id:
return
if gen._start_ns == 0: # gen() was never called
return
try:
input_text = (gen._prompt or "")[:LANGFUSE_PROMPT_LIMIT]
output_text = (gen.response or "")[:LANGFUSE_PROMPT_LIMIT]
usage = {
"input": gen.input_tokens,
"output": gen.output_tokens,
"total": gen.input_tokens + gen.output_tokens,
}
metadata = {
"latency_ms": round(gen.elapsed_ms, 1),
"max_tokens": gen_kwargs.get("max_tokens"),
"temperature": gen_kwargs.get("temperature"),
}
client.create_generation(
trace_id=trace_id,
name=node_name,
model=gen.model_name,
input=input_text,
output=output_text,
usage=usage,
metadata=metadata,
)
except Exception as e:
logger.debug("Failed to create Langfuse generation: %s", e)
def get_current_trace_id() -> Optional[str]:
"""Return the current Langfuse trace ID, or None."""
client = get_langfuse_client()
if client is None:
return None
try:
return client.get_trace_id()
except Exception:
return None
def push_score(trace_id: str, name: str, value: float, data_type: str = "NUMERIC") -> None:
"""Push an evaluation score to a Langfuse trace."""
client = get_langfuse_client()
if client is None or not trace_id:
return
try:
client.create_score(
trace_id=trace_id,
name=name,
value=value,
data_type=data_type,
)
logger.debug("Pushed score %s=%s → trace %s", name, value, trace_id[:8])
except Exception as e:
logger.debug("Failed to push score: %s", e)
|