#!/usr/bin/env uv run """ Claude Code -> Langfuse hook Sends Claude Code conversation turns to Langfuse as traces with spans, generations, and tool observations. Runs on the "Stop" hook (after each assistant turn) and reads the JSONL transcript incrementally. Setup ===== 1. Register the hook in .claude/settings.json (committed to repo): { "hooks": { "Stop": [ { "hooks": [ { "type": "command", "command": "uv run --project /path/to/project .claude/hooks/langfuse_hook.py" } ] } ] } } 2. Add credentials and config in .claude/settings.local.json (gitignored): { "env": { "TRACE_TO_LANGFUSE": "true", "LANGFUSE_PUBLIC_KEY": "pk-lf-...", "LANGFUSE_SECRET_KEY": "sk-lf-...", "LANGFUSE_BASE_URL": "https://cloud.langfuse.com", "CC_LANGFUSE_USER_ID": "user@example.com", "CC_LANGFUSE_ENVIRONMENT": "my-project" } } Environment variables ===================== Required (in settings.local.json env): TRACE_TO_LANGFUSE Set to "true" to enable tracing. LANGFUSE_PUBLIC_KEY Langfuse project public key. LANGFUSE_SECRET_KEY Langfuse project secret key. Optional: LANGFUSE_BASE_URL Langfuse host (default: https://cloud.langfuse.com). CC_LANGFUSE_USER_ID User ID attached to all traces (e.g. email). CC_LANGFUSE_ENVIRONMENT Environment name for Langfuse (e.g. project name). Must match: ^(?!langfuse)[a-z0-9-_]+$ (max 40 chars). CC_LANGFUSE_DEBUG Set to "true" for verbose logging. CC_LANGFUSE_MAX_CHARS Max characters before truncation (default: 20000). Trace metadata ============== Each trace/span includes the following metadata keys: source Always "claude-code". session_id Claude Code session UUID. turn_number Sequential turn number within the session. transcript_path Local path to the JSONL transcript file. user_text Truncation info for the user message. host_ip Public IP of the machine (via api.ipify.org). host_name OS hostname of the machine. host_cwd Working directory where Claude Code was invoked. Notes ===== - settings.json is committed and shared; settings.local.json holds secrets and per-user config and should be gitignored. - The hook fails open: if Langfuse is unreachable or misconfigured, Claude Code continues normally. """ import json import os import socket import sys import time import hashlib from dataclasses import dataclass from datetime import datetime, timezone from pathlib import Path from typing import Any, Dict, List, Optional, Tuple # --- Langfuse import (fail-open) --- try: from langfuse import Langfuse, propagate_attributes except Exception: sys.exit(0) # --- Paths --- STATE_DIR = Path.home() / ".claude" / "state" LOG_FILE = STATE_DIR / "langfuse_hook.log" STATE_FILE = STATE_DIR / "langfuse_state.json" LOCK_FILE = STATE_DIR / "langfuse_state.lock" DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true" MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000")) # ----------------- Logging ----------------- def _log(level: str, message: str) -> None: try: STATE_DIR.mkdir(parents=True, exist_ok=True) ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S") with open(LOG_FILE, "a", encoding="utf-8") as f: f.write(f"{ts} [{level}] {message}\n") except Exception: # Never block pass def debug(msg: str) -> None: if DEBUG: _log("DEBUG", msg) def info(msg: str) -> None: _log("INFO", msg) def warn(msg: str) -> None: _log("WARN", msg) def error(msg: str) -> None: _log("ERROR", msg) # ----------------- State locking (best-effort) ----------------- class FileLock: def __init__(self, path: Path, timeout_s: float = 2.0): self.path = path self.timeout_s = timeout_s self._fh = None def __enter__(self): STATE_DIR.mkdir(parents=True, exist_ok=True) self._fh = open(self.path, "a+", encoding="utf-8") try: import fcntl # Unix only deadline = time.time() + self.timeout_s while True: try: fcntl.flock(self._fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) break except BlockingIOError: if time.time() > deadline: break time.sleep(0.05) except Exception: # If locking isn't available, proceed without it. pass return self def __exit__(self, exc_type, exc, tb): try: import fcntl fcntl.flock(self._fh.fileno(), fcntl.LOCK_UN) except Exception: pass try: self._fh.close() except Exception: pass def load_state() -> Dict[str, Any]: try: if not STATE_FILE.exists(): return {} return json.loads(STATE_FILE.read_text(encoding="utf-8")) except Exception: return {} def save_state(state: Dict[str, Any]) -> None: try: STATE_DIR.mkdir(parents=True, exist_ok=True) tmp = STATE_FILE.with_suffix(".tmp") tmp.write_text(json.dumps(state, indent=2, sort_keys=True), encoding="utf-8") os.replace(tmp, STATE_FILE) except Exception as e: debug(f"save_state failed: {e}") def state_key(session_id: str, transcript_path: str) -> str: # stable key even if session_id collides raw = f"{session_id}::{transcript_path}" return hashlib.sha256(raw.encode("utf-8")).hexdigest() # ----------------- Hook payload ----------------- def read_hook_payload() -> Dict[str, Any]: """ Claude Code hooks pass a JSON payload on stdin. This script tolerates missing/empty stdin by returning {}. """ try: data = sys.stdin.read() if not data.strip(): return {} return json.loads(data) except Exception: return {} def extract_session_and_transcript( payload: Dict[str, Any], ) -> Tuple[Optional[str], Optional[Path]]: """ Tries a few plausible field names; exact keys can vary across hook types/versions. Prefer structured values from stdin over heuristics. """ session_id = ( payload.get("sessionId") or payload.get("session_id") or payload.get("session", {}).get("id") ) transcript = ( payload.get("transcriptPath") or payload.get("transcript_path") or payload.get("transcript", {}).get("path") ) if transcript: try: transcript_path = Path(transcript).expanduser().resolve() except Exception: transcript_path = None else: transcript_path = None return session_id, transcript_path # ----------------- Transcript parsing helpers ----------------- def get_content(msg: Dict[str, Any]) -> Any: if not isinstance(msg, dict): return None if "message" in msg and isinstance(msg.get("message"), dict): return msg["message"].get("content") return msg.get("content") def get_role(msg: Dict[str, Any]) -> Optional[str]: # Claude Code transcript lines commonly have type=user/assistant OR message.role t = msg.get("type") if t in ("user", "assistant"): return t m = msg.get("message") if isinstance(m, dict): r = m.get("role") if r in ("user", "assistant"): return r return None def is_tool_result(msg: Dict[str, Any]) -> bool: role = get_role(msg) if role != "user": return False content = get_content(msg) if isinstance(content, list): return any( isinstance(x, dict) and x.get("type") == "tool_result" for x in content ) return False def iter_tool_results(content: Any) -> List[Dict[str, Any]]: out: List[Dict[str, Any]] = [] if isinstance(content, list): for x in content: if isinstance(x, dict) and x.get("type") == "tool_result": out.append(x) return out def iter_tool_uses(content: Any) -> List[Dict[str, Any]]: out: List[Dict[str, Any]] = [] if isinstance(content, list): for x in content: if isinstance(x, dict) and x.get("type") == "tool_use": out.append(x) return out def extract_text(content: Any) -> str: if isinstance(content, str): return content if isinstance(content, list): parts: List[str] = [] for x in content: if isinstance(x, dict) and x.get("type") == "text": parts.append(x.get("text", "")) elif isinstance(x, str): parts.append(x) return "\n".join([p for p in parts if p]) return "" def truncate_text(s: str, max_chars: int = MAX_CHARS) -> Tuple[str, Dict[str, Any]]: if s is None: return "", {"truncated": False, "orig_len": 0} orig_len = len(s) if orig_len <= max_chars: return s, {"truncated": False, "orig_len": orig_len} head = s[:max_chars] return head, { "truncated": True, "orig_len": orig_len, "kept_len": len(head), "sha256": hashlib.sha256(s.encode("utf-8")).hexdigest(), } def get_model(msg: Dict[str, Any]) -> str: m = msg.get("message") if isinstance(m, dict): return m.get("model") or "claude" return "claude" def get_message_id(msg: Dict[str, Any]) -> Optional[str]: m = msg.get("message") if isinstance(m, dict): mid = m.get("id") if isinstance(mid, str) and mid: return mid return None # ----------------- Incremental reader ----------------- @dataclass class SessionState: offset: int = 0 buffer: str = "" turn_count: int = 0 def load_session_state(global_state: Dict[str, Any], key: str) -> SessionState: s = global_state.get(key, {}) return SessionState( offset=int(s.get("offset", 0)), buffer=str(s.get("buffer", "")), turn_count=int(s.get("turn_count", 0)), ) def write_session_state( global_state: Dict[str, Any], key: str, ss: SessionState ) -> None: global_state[key] = { "offset": ss.offset, "buffer": ss.buffer, "turn_count": ss.turn_count, "updated": datetime.now(timezone.utc).isoformat(), } def read_new_jsonl( transcript_path: Path, ss: SessionState ) -> Tuple[List[Dict[str, Any]], SessionState]: """ Reads only new bytes since ss.offset. Keeps ss.buffer for partial last line. Returns parsed JSON lines (best-effort) and updated state. """ if not transcript_path.exists(): return [], ss try: with open(transcript_path, "rb") as f: f.seek(ss.offset) chunk = f.read() new_offset = f.tell() except Exception as e: debug(f"read_new_jsonl failed: {e}") return [], ss if not chunk: return [], ss try: text = chunk.decode("utf-8", errors="replace") except Exception: text = chunk.decode(errors="replace") combined = ss.buffer + text lines = combined.split("\n") # last element may be incomplete ss.buffer = lines[-1] ss.offset = new_offset msgs: List[Dict[str, Any]] = [] for line in lines[:-1]: line = line.strip() if not line: continue try: msgs.append(json.loads(line)) except Exception: continue return msgs, ss # ----------------- Turn assembly ----------------- @dataclass class Turn: user_msg: Dict[str, Any] assistant_msgs: List[Dict[str, Any]] tool_results_by_id: Dict[str, Any] def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]: """ Groups incremental transcript rows into turns: user (non-tool-result) -> assistant messages -> (tool_result rows, possibly interleaved) Uses: - assistant message dedupe by message.id (latest row wins) - tool results dedupe by tool_use_id (latest wins) """ turns: List[Turn] = [] current_user: Optional[Dict[str, Any]] = None # assistant messages for current turn: assistant_order: List[ str ] = [] # message ids in order of first appearance (or synthetic) assistant_latest: Dict[str, Dict[str, Any]] = {} # id -> latest msg tool_results_by_id: Dict[str, Any] = {} # tool_use_id -> content def flush_turn(): nonlocal \ current_user, \ assistant_order, \ assistant_latest, \ tool_results_by_id, \ turns if current_user is None: return if not assistant_latest: return assistants = [ assistant_latest[mid] for mid in assistant_order if mid in assistant_latest ] turns.append( Turn( user_msg=current_user, assistant_msgs=assistants, tool_results_by_id=dict(tool_results_by_id), ) ) for msg in messages: role = get_role(msg) # tool_result rows show up as role=user with content blocks of type tool_result if is_tool_result(msg): for tr in iter_tool_results(get_content(msg)): tid = tr.get("tool_use_id") if tid: tool_results_by_id[str(tid)] = tr.get("content") continue if role == "user": # new user message -> finalize previous turn flush_turn() # start a new turn current_user = msg assistant_order = [] assistant_latest = {} tool_results_by_id = {} continue if role == "assistant": if current_user is None: # ignore assistant rows until we see a user message continue mid = get_message_id(msg) or f"noid:{len(assistant_order)}" if mid not in assistant_latest: assistant_order.append(mid) assistant_latest[mid] = msg continue # ignore unknown rows # flush last flush_turn() return turns # ----------------- Langfuse emit ----------------- def _tool_calls_from_assistants( assistant_msgs: List[Dict[str, Any]], ) -> List[Dict[str, Any]]: calls: List[Dict[str, Any]] = [] for am in assistant_msgs: for tu in iter_tool_uses(get_content(am)): tid = tu.get("id") or "" calls.append( { "id": str(tid), "name": tu.get("name") or "unknown", "input": tu.get("input") if isinstance(tu.get("input"), (dict, list, str, int, float, bool)) else {}, } ) return calls def emit_turn( langfuse: Langfuse, session_id: str, turn_num: int, turn: Turn, transcript_path: Path, host_meta: Optional[Dict[str, str]] = None, ) -> None: user_text_raw = extract_text(get_content(turn.user_msg)) user_text, user_text_meta = truncate_text(user_text_raw) last_assistant = turn.assistant_msgs[-1] assistant_text_raw = extract_text(get_content(last_assistant)) assistant_text, assistant_text_meta = truncate_text(assistant_text_raw) model = get_model(turn.assistant_msgs[0]) tool_calls = _tool_calls_from_assistants(turn.assistant_msgs) # attach tool outputs for c in tool_calls: if c["id"] and c["id"] in turn.tool_results_by_id: out_raw = turn.tool_results_by_id[c["id"]] out_str = ( out_raw if isinstance(out_raw, str) else json.dumps(out_raw, ensure_ascii=False) ) out_trunc, out_meta = truncate_text(out_str) c["output"] = out_trunc c["output_meta"] = out_meta else: c["output"] = None user_id = os.environ.get("CC_LANGFUSE_USER_ID") with propagate_attributes( session_id=session_id, user_id=user_id, trace_name=f"Claude Code - Turn {turn_num}", tags=["claude-code"], metadata=host_meta or None, ): with langfuse.start_as_current_span( name=f"Claude Code - Turn {turn_num}", input={"role": "user", "content": user_text}, metadata={ "source": "claude-code", "session_id": session_id, "turn_number": turn_num, "transcript_path": str(transcript_path), "user_text": user_text_meta, **(host_meta or {}), }, ) as trace_span: # LLM generation with langfuse.start_as_current_observation( name="Claude Response", as_type="generation", model=model, input={"role": "user", "content": user_text}, output={"role": "assistant", "content": assistant_text}, metadata={ "assistant_text": assistant_text_meta, "tool_count": len(tool_calls), }, ): pass # Tool observations for tc in tool_calls: in_obj = tc["input"] # truncate tool input if it's a large string payload if isinstance(in_obj, str): in_obj, in_meta = truncate_text(in_obj) else: in_meta = None with langfuse.start_as_current_observation( name=f"Tool: {tc['name']}", as_type="tool", input=in_obj, metadata={ "tool_name": tc["name"], "tool_id": tc["id"], "input_meta": in_meta, "output_meta": tc.get("output_meta"), }, ) as tool_obs: tool_obs.update(output=tc.get("output")) trace_span.update(output={"role": "assistant", "content": assistant_text}) # ----------------- Main ----------------- def main() -> int: start = time.time() debug("Hook started") if os.environ.get("TRACE_TO_LANGFUSE", "").lower() != "true": return 0 public_key = os.environ.get("CC_LANGFUSE_PUBLIC_KEY") or os.environ.get( "LANGFUSE_PUBLIC_KEY" ) secret_key = os.environ.get("CC_LANGFUSE_SECRET_KEY") or os.environ.get( "LANGFUSE_SECRET_KEY" ) host = ( os.environ.get("CC_LANGFUSE_BASE_URL") or os.environ.get("LANGFUSE_BASE_URL") or "https://cloud.langfuse.com" ) if not public_key or not secret_key: return 0 # Set environment for Langfuse tracing (must be set before client init) environment = os.environ.get("CC_LANGFUSE_ENVIRONMENT") if environment: os.environ.setdefault("LANGFUSE_TRACING_ENVIRONMENT", environment) # Build host identifier for metadata try: import urllib.request public_ip = ( urllib.request.urlopen("https://api.ipify.org", timeout=2) .read() .decode() .strip() ) except Exception: public_ip = "unknown" host_meta = { "host_ip": public_ip, "host_name": socket.gethostname(), "host_cwd": os.getcwd(), } payload = read_hook_payload() session_id, transcript_path = extract_session_and_transcript(payload) if not session_id or not transcript_path: # No structured payload; fail open (do not guess) debug("Missing session_id or transcript_path from hook payload; exiting.") return 0 if not transcript_path.exists(): debug(f"Transcript path does not exist: {transcript_path}") return 0 try: langfuse = Langfuse( public_key=public_key, secret_key=secret_key, host=host, environment=environment, ) except Exception: return 0 try: with FileLock(LOCK_FILE): state = load_state() key = state_key(session_id, str(transcript_path)) ss = load_session_state(state, key) msgs, ss = read_new_jsonl(transcript_path, ss) if not msgs: write_session_state(state, key, ss) save_state(state) return 0 turns = build_turns(msgs) if not turns: write_session_state(state, key, ss) save_state(state) return 0 # emit turns emitted = 0 for t in turns: emitted += 1 turn_num = ss.turn_count + emitted try: emit_turn( langfuse, session_id, turn_num, t, transcript_path, host_meta ) except Exception as e: debug(f"emit_turn failed: {e}") # continue emitting other turns ss.turn_count += emitted write_session_state(state, key, ss) save_state(state) try: langfuse.flush() except Exception: pass dur = time.time() - start info(f"Processed {emitted} turns in {dur:.2f}s (session={session_id})") return 0 except Exception as e: debug(f"Unexpected failure: {e}") return 0 finally: try: langfuse.shutdown() except Exception: pass if __name__ == "__main__": sys.exit(main())