promptlayer 1.2.0 → 1.2.2

package/vendor/claude-agents/trace/hooks/py/context.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+import os
+import subprocess
+
+
+PLUGIN_VERSION = "1.0.0"
+
+
+def env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, str(default)))
+    except Exception:
+        return default
+
+
+def detect_claude_version() -> str:
+    try:
+        result = subprocess.run(
+            ["claude", "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except Exception:
+        return "unknown"
+    return result.stdout.strip() or "unknown"
+
+
+@dataclass(frozen=True)
+class HookContext:
+    log_file: str
+    queue_file: str
+    session_state_dir: str
+    lock_dir: str
+    debug: str
+    api_key: str
+    otlp_endpoint: str
+    queue_drain_limit: int
+    otlp_connect_timeout: int
+    otlp_max_time: int
+    plugin_version: str
+    cc_version: str
+    user_agent: str
+
+
+def load_context() -> HookContext:
+    cc_version = detect_claude_version()
+    plugin_version = PLUGIN_VERSION
+    return HookContext(
+        log_file=os.path.expanduser("~/.claude/state/promptlayer_hook.log"),
+        queue_file=os.path.expanduser("~/.claude/state/promptlayer_otlp_queue.ndjson"),
+        session_state_dir=os.path.expanduser("~/.claude/state/promptlayer_sessions"),
+        lock_dir=os.path.expanduser("~/.claude/state/promptlayer_locks"),
+        debug=os.environ.get("PROMPTLAYER_CC_DEBUG", "false"),
+        api_key=os.environ.get("PROMPTLAYER_API_KEY", ""),
+        otlp_endpoint=os.environ.get("PROMPTLAYER_OTLP_ENDPOINT", "https://api.promptlayer.com/v1/traces"),
+        queue_drain_limit=env_int("PROMPTLAYER_QUEUE_DRAIN_LIMIT", 10),
+        otlp_connect_timeout=env_int("PROMPTLAYER_OTLP_CONNECT_TIMEOUT", 5),
+        otlp_max_time=env_int("PROMPTLAYER_OTLP_MAX_TIME", 12),
+        plugin_version=plugin_version,
+        cc_version=cc_version,
+        user_agent=f"promptlayer-claude-plugin/{plugin_version} claude-code/{cc_version}",
+    )

package/vendor/claude-agents/trace/hooks/py/handlers.py

@@ -0,0 +1,244 @@
+import json
+import os
+import time
+from typing import Optional
+
+from otlp import (
+    SpanSpec,
+    build_payload,
+    build_span,
+    generate_session_id,
+    generate_span_id,
+    generate_trace_id,
+    send_payload_with_queueing,
+)
+from state import (
+    acquire_lock,
+    ensure_session_initialized,
+    load_session_state,
+    parse_pending_tool_calls,
+    release_lock,
+    save_session_state,
+    session_lock_path,
+)
+from stop_parser import build_stop_hook_span_specs, parse_transcript
+from traceparent import parse_traceparent
+
+
+def read_stdin_json(raw: str):
+    if not raw.strip():
+        return {}
+    try:
+        data = json.loads(raw)
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def handle_session_start(ctx, raw_input: str) -> str:
+    input_data = read_stdin_json(raw_input)
+    session_id = input_data.get("session_id")
+    session_id = str(session_id) if session_id else generate_session_id()
+
+    state, path = load_session_state(ctx.session_state_dir, session_id)
+    existing = bool(state.trace_id and state.session_span_id)
+    if existing:
+        state, _ = ensure_session_initialized(
+            state,
+            traceparent_raw=os.environ.get("PROMPTLAYER_TRACEPARENT", ""),
+            generate_trace_id=generate_trace_id,
+            generate_span_id=generate_span_id,
+        )
+        status = "existing"
+    else:
+        trace_context = parse_traceparent(os.environ.get("PROMPTLAYER_TRACEPARENT", ""))
+        state.trace_id = trace_context["trace_id"] if trace_context else generate_trace_id()
+        state.session_span_id = generate_span_id()
+        state.session_parent_span_id = trace_context["parent_span_id"] if trace_context else ""
+        state.session_start_ns = str(time.time_ns())
+        state.current_turn_start_ns = ""
+        state.pending_tool_calls = "[]"
+        state.session_init_source = "session_start_hook"
+        state.session_traceparent_version = trace_context["version"] if trace_context else ""
+        state.session_trace_flags = trace_context["trace_flags"] if trace_context else ""
+        state.trace_context_source = trace_context["source"] if trace_context else "generated"
+        status = "captured"
+
+    save_session_state(path, state)
+    return f"{session_id}\t{state.trace_id}\t{status}"
+
+
+def handle_user_prompt_submit(ctx, raw_input: str) -> str:
+    input_data = read_stdin_json(raw_input)
+    session_id = input_data.get("session_id")
+    if not session_id:
+        return ""
+
+    state, path = load_session_state(ctx.session_state_dir, str(session_id))
+    state, _ = ensure_session_initialized(
+        state,
+        traceparent_raw=os.environ.get("PROMPTLAYER_TRACEPARENT", ""),
+        generate_trace_id=generate_trace_id,
+        generate_span_id=generate_span_id,
+    )
+    if not state.trace_id or not state.session_span_id:
+        return ""
+
+    state.current_turn_start_ns = str(time.time_ns())
+    state.pending_tool_calls = "[]"
+    save_session_state(path, state)
+    return str(session_id)
+
+
+def handle_post_tool_use(ctx, raw_input: str) -> str:
+    input_data = read_stdin_json(raw_input)
+    session_id = input_data.get("session_id")
+    tool_name = input_data.get("tool_name")
+    if not session_id or not tool_name:
+        return ""
+
+    tool_input = input_data.get("tool_input", {})
+    tool_output = input_data.get("tool_response", input_data.get("output", {}))
+
+    state, path = load_session_state(ctx.session_state_dir, str(session_id))
+    state, _ = ensure_session_initialized(
+        state,
+        traceparent_raw=os.environ.get("PROMPTLAYER_TRACEPARENT", ""),
+        generate_trace_id=generate_trace_id,
+        generate_span_id=generate_span_id,
+    )
+    if not state.trace_id:
+        return ""
+    if not state.current_turn_start_ns:
+        state.current_turn_start_ns = str(time.time_ns())
+
+    pending_tool_calls = parse_pending_tool_calls(state.pending_tool_calls)
+    pending_tool_calls.append(
+        {
+            "source": "claude-code",
+            "hook": "PostToolUse",
+            "tool_name": str(tool_name),
+            "node_type": "CODE_EXECUTION",
+            "function_input": tool_input,
+            "function_output": tool_output,
+        }
+    )
+    state.pending_tool_calls = json.dumps(pending_tool_calls, ensure_ascii=False, separators=(",", ":"))
+    save_session_state(path, state)
+    return f"{session_id}\t{tool_name}"
+
+
+def handle_session_end(ctx, raw_input: str) -> str:
+    input_data = read_stdin_json(raw_input)
+    session_id = input_data.get("session_id")
+    if not session_id:
+        return ""
+
+    lock_path = session_lock_path(ctx.lock_dir, str(session_id))
+    if not acquire_lock(lock_path):
+        return ""
+
+    try:
+        state, path = load_session_state(ctx.session_state_dir, str(session_id))
+        if not state.trace_id or not state.session_span_id:
+            return ""
+
+        spec = build_span(
+            SpanSpec(
+                trace_id=state.trace_id,
+                span_id=state.session_span_id,
+                parent_span_id=state.session_parent_span_id,
+                name="Claude Code session",
+                kind="1",
+                start_ns=state.session_start_ns or str(time.time_ns()),
+                end_ns=str(time.time_ns()),
+                attrs={
+                    "source": "claude-code",
+                    "hook": "SessionEnd",
+                    "node_type": "WORKFLOW",
+                    "session.lifecycle": "complete",
+                },
+            )
+        )
+        send_payload_with_queueing(ctx, build_payload([spec]))
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+        return str(session_id)
+    finally:
+        release_lock(lock_path)
+
+
+def resolve_stop_session_id(input_data):
+    session_id = input_data.get("session_id")
+    transcript_path = input_data.get("transcript_path")
+    if not session_id and transcript_path:
+        session_id = os.path.basename(str(transcript_path))
+        if session_id.endswith(".jsonl"):
+            session_id = session_id[: -len(".jsonl")]
+    return session_id
+
+
+def handle_stop_hook(ctx, raw_input: str) -> str:
+    input_data = read_stdin_json(raw_input)
+    session_id = resolve_stop_session_id(input_data)
+    transcript_path = input_data.get("transcript_path")
+    if not session_id:
+        return ""
+
+    lock_path = session_lock_path(ctx.lock_dir, str(session_id))
+    if not acquire_lock(lock_path):
+        return ""
+
+    try:
+        state, path = load_session_state(ctx.session_state_dir, str(session_id))
+        state, _ = ensure_session_initialized(
+            state,
+            traceparent_raw=os.environ.get("PROMPTLAYER_TRACEPARENT", ""),
+            generate_trace_id=generate_trace_id,
+            generate_span_id=generate_span_id,
+        )
+        if not state.trace_id or not state.session_span_id:
+            return ""
+
+        turn_start_ns = state.current_turn_start_ns or str(time.time_ns())
+        pending_tool_calls = state.pending_tool_calls or "[]"
+        state.current_turn_start_ns = ""
+        state.pending_tool_calls = "[]"
+        save_session_state(path, state)
+    finally:
+        release_lock(lock_path)
+
+    if not transcript_path or not os.path.exists(str(transcript_path)):
+        return f"{session_id}\tmissing_transcript"
+
+    pending_payloads = parse_pending_tool_calls(pending_tool_calls)
+    attempts = 0
+    while True:
+        parsed = parse_transcript(str(transcript_path), int(turn_start_ns), pending_payloads, str(session_id))
+        if parsed.get("llms") or attempts >= 10:
+            break
+        attempts += 1
+        time.sleep(0.2)
+
+    span_specs = build_stop_hook_span_specs(
+        parsed=parsed,
+        trace_id=state.trace_id,
+        session_span_id=state.session_span_id,
+        session_parent_span_id=state.session_parent_span_id,
+        session_start_ns=state.session_start_ns or str(time.time_ns()),
+        session_init_source=state.session_init_source,
+        generate_span_id=generate_span_id,
+    )
+    spans = [build_span(span_spec) for span_spec in span_specs]
+    if spans:
+        send_payload_with_queueing(ctx, build_payload(spans))
+    return f"{session_id}\tok"
+
+
+def handle_parse_stop_transcript(transcript_path: str, turn_start_ns: str, expected_session_id: Optional[str]) -> str:
+    pending_raw = os.environ.get("PL_PENDING_TOOL_CALLS", "[]")
+    pending_payloads = parse_pending_tool_calls(pending_raw)
+    parsed = parse_transcript(transcript_path, int(turn_start_ns) or None, pending_payloads, expected_session_id)
+    return json.dumps(parsed, ensure_ascii=False, separators=(",", ":"))

package/vendor/claude-agents/trace/hooks/py/otlp.py

@@ -0,0 +1,278 @@
+from dataclasses import dataclass
+import base64
+import binascii
+import json
+import os
+import secrets
+import uuid
+from urllib import error, request
+
+from state import acquire_lock, queue_lock_path, release_lock
+
+
+@dataclass
+class SpanSpec:
+    trace_id: str
+    span_id: str
+    parent_span_id: str
+    name: str
+    kind: str
+    start_ns: str
+    end_ns: str
+    attrs: dict
+
+
+def compact_json(value) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+
+
+def generate_trace_id() -> str:
+    return secrets.token_hex(16)
+
+
+def generate_span_id() -> str:
+    return secrets.token_hex(8)
+
+
+def generate_session_id() -> str:
+    return str(uuid.uuid4())
+
+
+def normalize_hex_id(raw: str, expected_len: int, fallback: str) -> str:
+    clean = "".join(ch for ch in str(raw).lower() if ch in "0123456789abcdef")
+    if not clean:
+        clean = fallback
+    if len(clean) > expected_len:
+        clean = clean[:expected_len]
+    if len(clean) < expected_len:
+        clean = clean.ljust(expected_len, "0")
+    return clean
+
+
+def hex_to_base64(hex_value: str) -> str:
+    raw = binascii.unhexlify(hex_value)
+    return base64.b64encode(raw).decode("ascii")
+
+
+def kind_int_to_string(kind) -> str:
+    value = str(kind)
+    return {
+        "0": "SPAN_KIND_UNSPECIFIED",
+        "1": "SPAN_KIND_INTERNAL",
+        "2": "SPAN_KIND_SERVER",
+        "3": "SPAN_KIND_CLIENT",
+        "4": "SPAN_KIND_PRODUCER",
+        "5": "SPAN_KIND_CONSUMER",
+    }.get(value, "SPAN_KIND_UNSPECIFIED")
+
+
+def otlp_attribute_value(value):
+    if isinstance(value, str):
+        return {"stringValue": value}
+    if isinstance(value, bool):
+        return {"boolValue": value}
+    if isinstance(value, int):
+        return {"intValue": str(value)}
+    if isinstance(value, float):
+        if value.is_integer():
+            return {"intValue": str(int(value))}
+        return {"doubleValue": value}
+    return {"stringValue": compact_json(value)}
+
+
+def build_span(spec: SpanSpec):
+    trace_id = normalize_hex_id(spec.trace_id, 32, generate_trace_id())
+    span_id = normalize_hex_id(spec.span_id, 16, generate_span_id())
+    parent_span = ""
+    if spec.parent_span_id:
+        parent_span = normalize_hex_id(spec.parent_span_id, 16, generate_span_id())
+
+    attributes = []
+    for key, value in (spec.attrs or {}).items():
+        if value is None:
+            continue
+        attributes.append({"key": key, "value": otlp_attribute_value(value)})
+
+    span = {
+        "traceId": hex_to_base64(trace_id),
+        "spanId": hex_to_base64(span_id),
+        "name": spec.name,
+        "kind": kind_int_to_string(spec.kind),
+        "startTimeUnixNano": str(spec.start_ns),
+        "endTimeUnixNano": str(spec.end_ns),
+        "attributes": attributes,
+    }
+    if parent_span:
+        span["parentSpanId"] = hex_to_base64(parent_span)
+    return span
+
+
+def build_payload(spans):
+    return {
+        "resourceSpans": [
+            {
+                "resource": {
+                    "attributes": [
+                        {"key": "service.name", "value": {"stringValue": "claude-code"}}
+                    ]
+                },
+                "scopeSpans": [{"spans": spans}],
+            }
+        ]
+    }
+
+
+def http_post_json(endpoint: str, payload, api_key: str = "", user_agent: str = "", timeout: int = 12):
+    body = compact_json(payload).encode("utf-8")
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["X-Api-Key"] = api_key
+    if user_agent:
+        headers["User-Agent"] = user_agent
+
+    req = request.Request(endpoint, data=body, headers=headers, method="POST")
+    try:
+        with request.urlopen(req, timeout=max(timeout, 1)) as response:
+            return response.getcode(), response.read().decode("utf-8")
+    except error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+    except Exception:
+        return 0, ""
+
+
+def parse_partial_success(response_text: str):
+    if not response_text:
+        return 0, ""
+    try:
+        parsed = json.loads(response_text)
+    except Exception:
+        return 0, ""
+    partial = parsed.get("partialSuccess", {})
+    if not isinstance(partial, dict):
+        return 0, ""
+    rejected = partial.get("rejectedSpans", 0)
+    try:
+        rejected_int = int(rejected)
+    except Exception:
+        rejected_int = 0
+    message = partial.get("errorMessage", "")
+    return rejected_int, str(message) if message else ""
+
+
+def post_otlp_payload(ctx, payload):
+    return http_post_json(
+        ctx.otlp_endpoint,
+        payload,
+        api_key=ctx.api_key,
+        user_agent=ctx.user_agent,
+        timeout=ctx.otlp_max_time,
+    )
+
+
+def append_queue_payload(ctx, payload):
+    if not ctx.queue_file or not ctx.lock_dir:
+        return False
+
+    os.makedirs(os.path.dirname(ctx.queue_file), exist_ok=True)
+    lock_path = queue_lock_path(ctx.lock_dir)
+    if not acquire_lock(lock_path):
+        return False
+    try:
+        with open(ctx.queue_file, "a", encoding="utf-8") as f:
+            f.write(compact_json(payload))
+            f.write("\n")
+        try:
+            os.chmod(ctx.queue_file, 0o600)
+        except Exception:
+            pass
+        return True
+    finally:
+        release_lock(lock_path)
+
+
+def read_queue_payloads(queue_file: str):
+    if not os.path.exists(queue_file) or os.path.getsize(queue_file) == 0:
+        return []
+
+    payloads = []
+    with open(queue_file, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                payloads.append(json.loads(line))
+            except Exception:
+                continue
+    return payloads
+
+
+def write_queue_payloads(queue_file: str, payloads) -> None:
+    os.makedirs(os.path.dirname(queue_file), exist_ok=True)
+    with open(queue_file, "w", encoding="utf-8") as f:
+        for payload in payloads:
+            f.write(compact_json(payload))
+            f.write("\n")
+    try:
+        os.chmod(queue_file, 0o600)
+    except Exception:
+        pass
+
+
+def post_payload_result(ctx, payload):
+    status, response_text = post_otlp_payload(ctx, payload)
+    if status != 200:
+        return 1
+    rejected, _ = parse_partial_success(response_text)
+    if rejected:
+        return 2
+    return 0
+
+
+def drain_queue(ctx):
+    if not ctx.queue_file or not ctx.lock_dir or not os.path.exists(ctx.queue_file):
+        return
+    if ctx.queue_drain_limit <= 0:
+        return
+
+    lock_path = queue_lock_path(ctx.lock_dir)
+    if not acquire_lock(lock_path):
+        return
+    try:
+        payloads = read_queue_payloads(ctx.queue_file)
+        if not payloads:
+            return
+
+        max_attempts = min(len(payloads), ctx.queue_drain_limit)
+        remaining_start = max_attempts
+        for idx in range(max_attempts):
+            result = post_payload_result(ctx, payloads[idx])
+            if result == 0:
+                continue
+            if result == 2:
+                continue
+            remaining_start = idx
+            break
+
+        if max_attempts < len(payloads):
+            remaining = payloads[remaining_start:]
+        elif remaining_start < max_attempts:
+            remaining = payloads[remaining_start:]
+        else:
+            remaining = payloads[max_attempts:]
+        write_queue_payloads(ctx.queue_file, remaining)
+    finally:
+        release_lock(lock_path)
+
+
+def send_payload_with_queueing(ctx, payload):
+    drain_queue(ctx)
+    result = post_payload_result(ctx, payload)
+    if result == 1:
+        append_queue_payload(ctx, payload)
+    return result
+
+
+def probe_endpoint(endpoint: str, api_key: str) -> str:
+    status, _ = http_post_json(endpoint, {"resourceSpans": []}, api_key=api_key, timeout=12)
+    return f"{status:03d}" if status else "000"

package/vendor/claude-agents/trace/hooks/py/settings.py

@@ -0,0 +1,33 @@
+import json
+import os
+
+
+def write_settings_env(settings_file: str, api_key: str, endpoint: str, debug: str) -> str:
+    env_values = {
+        "TRACE_TO_PROMPTLAYER": "true",
+        "PROMPTLAYER_API_KEY": api_key,
+        "PROMPTLAYER_OTLP_ENDPOINT": endpoint,
+        "PROMPTLAYER_CC_DEBUG": debug,
+    }
+
+    settings = {}
+    if os.path.exists(settings_file):
+        try:
+            with open(settings_file, encoding="utf-8") as f:
+                settings = json.load(f)
+        except Exception as exc:
+            raise SystemExit(f"invalid settings json: {exc}")
+        if not isinstance(settings, dict):
+            raise SystemExit("invalid settings json: root must be an object")
+
+    current_env = settings.get("env", {})
+    if not isinstance(current_env, dict):
+        current_env = {}
+    current_env.update(env_values)
+    settings["env"] = current_env
+
+    os.makedirs(os.path.dirname(settings_file), exist_ok=True)
+    with open(settings_file, "w", encoding="utf-8") as f:
+        json.dump(settings, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+    return settings_file