| """ |
| 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 |
|
|
| |
| @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: |
| 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) |
|
|
