promptlayer 1.2.1 → 1.2.2

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

@@ -0,0 +1,135 @@
+from dataclasses import dataclass
+import json
+import os
+import shutil
+import time
+
+from traceparent import parse_traceparent
+
+
+@dataclass
+class SessionState:
+    trace_id: str = ""
+    session_span_id: str = ""
+    session_parent_span_id: str = ""
+    session_start_ns: str = ""
+    current_turn_start_ns: str = ""
+    pending_tool_calls: str = ""
+    session_init_source: str = ""
+    session_traceparent_version: str = ""
+    session_trace_flags: str = ""
+    trace_context_source: str = ""
+
+    @classmethod
+    def from_dict(cls, data):
+        if not isinstance(data, dict):
+            return cls()
+        return cls(**{field: str(data.get(field, "")) for field in cls.__dataclass_fields__})
+
+    def to_dict(self):
+        return {field: getattr(self, field, "") for field in self.__dataclass_fields__}
+
+
+def compact_json(value) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+
+
+def session_state_path(session_state_dir: str, session_id: str) -> str:
+    return os.path.join(session_state_dir, f"{session_id}.json")
+
+
+def load_session_state(session_state_dir: str, session_id: str):
+    path = session_state_path(session_state_dir, session_id)
+    if not os.path.exists(path):
+        return SessionState(), path
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception:
+        return SessionState(), path
+    return SessionState.from_dict(data), path
+
+
+def save_session_state(path: str, state: SessionState) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(state.to_dict(), f, ensure_ascii=False, separators=(",", ":"))
+
+
+def parse_pending_tool_calls(raw: str):
+    if not raw:
+        return []
+    try:
+        data = json.loads(raw)
+    except Exception:
+        return []
+    return data if isinstance(data, list) else []
+
+
+def session_lock_path(lock_dir: str, session_id: str) -> str:
+    return os.path.join(lock_dir, f"{session_id}.lock")
+
+
+def queue_lock_path(lock_dir: str) -> str:
+    return os.path.join(lock_dir, "queue.lock")
+
+
+def acquire_lock(path: str, attempts: int = 250, sleep_seconds: float = 0.02) -> bool:
+    for _ in range(attempts):
+        try:
+            os.mkdir(path)
+            return True
+        except FileExistsError:
+            time.sleep(sleep_seconds)
+        except Exception:
+            return False
+    return False
+
+
+def release_lock(path: str) -> None:
+    try:
+        os.rmdir(path)
+    except Exception:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+def ensure_session_initialized(
+    state: SessionState,
+    *,
+    traceparent_raw: str,
+    generate_trace_id,
+    generate_span_id,
+    requested_start_ns=None,
+):
+    if state.trace_id and state.session_span_id:
+        if not state.session_start_ns:
+            state.session_start_ns = str(requested_start_ns or time.time_ns())
+        if not state.session_init_source:
+            state.session_init_source = "unknown"
+        if not state.pending_tool_calls:
+            state.pending_tool_calls = "[]"
+        if not state.session_parent_span_id:
+            state.session_parent_span_id = ""
+        if not state.session_traceparent_version:
+            state.session_traceparent_version = ""
+        if not state.session_trace_flags:
+            state.session_trace_flags = ""
+        if not state.trace_context_source:
+            state.trace_context_source = "generated"
+        return state, False
+
+    trace_context = parse_traceparent(traceparent_raw)
+    if requested_start_ns is None:
+        requested_start_ns = time.time_ns()
+
+    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(requested_start_ns)
+    state.current_turn_start_ns = ""
+    state.pending_tool_calls = "[]"
+    state.session_init_source = "lazy_init"
+    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"
+    return state, True

package/vendor/claude-agents/trace/hooks/{parse_stop_transcript.py → py/stop_parser.py}

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-"""Parse a Claude transcript and return finalized turn/tool/llm spans as JSON."""
+"""Pure transcript parsing and stop-hook span-spec derivation."""
 
 import json
-import os
-import sys
 from datetime import datetime, timezone
 
+from otlp import SpanSpec
+
 
 def parse_iso_to_ns(raw):
     if not raw:
@@ -172,9 +172,9 @@ def parse_transcript(transcript_path, turn_start_fallback, pending_payloads, exp
                 is_error = bool(block.get("is_error", False))
 
                 match_idx = None
-                for idx, item in enumerate(pending_tool_uses):
+                for candidate_idx, item in enumerate(pending_tool_uses):
                     if tool_use_id and item.get("id") == tool_use_id:
-                        match_idx = idx
+                        match_idx = candidate_idx
                         break
                 if match_idx is None and pending_tool_uses:
                     match_idx = 0
@@ -277,8 +277,6 @@ def parse_transcript(transcript_path, turn_start_fallback, pending_payloads, exp
                     }
                 )
 
-        # Claude can emit intermediate assistant records that contain only
-        # empty thinking blocks. Those should not consume the user's prompt.
         if not output_text and not tool_calls:
             continue
 
@@ -345,31 +343,71 @@ def parse_transcript(transcript_path, turn_start_fallback, pending_payloads, exp
     }
 
 
-def main():
-    if len(sys.argv) < 3:
-        print(
-            json.dumps(
-                {"error": "Usage: parse_stop_transcript.py <transcript_path> <turn_start_ns> [session_id]"}
+def build_stop_hook_span_specs(
+    *,
+    parsed,
+    trace_id,
+    session_span_id,
+    session_parent_span_id,
+    session_start_ns,
+    session_init_source,
+    generate_span_id,
+):
+    turn = parsed.get("turn", {})
+    turn_start_ns = str(turn.get("start_ns", session_start_ns))
+    turn_end_ns = str(turn.get("end_ns", turn_start_ns))
+
+    if session_init_source == "lazy_init":
+        session_hook_attr = "StopFallback"
+        session_lifecycle_attr = "stop_fallback"
+    else:
+        session_hook_attr = "Stop"
+        session_lifecycle_attr = "in_progress"
+
+    span_specs = [
+        SpanSpec(
+            trace_id=trace_id,
+            span_id=session_span_id,
+            parent_span_id=session_parent_span_id,
+            name="Claude Code session",
+            kind="1",
+            start_ns=str(session_start_ns),
+            end_ns=turn_end_ns,
+            attrs={
+                "source": "claude-code",
+                "hook": session_hook_attr,
+                "node_type": "WORKFLOW",
+                "session.lifecycle": session_lifecycle_attr,
+            },
+        )
+    ]
+
+    for tool in parsed.get("tools", []):
+        span_specs.append(
+            SpanSpec(
+                trace_id=trace_id,
+                span_id=generate_span_id(),
+                parent_span_id=session_span_id,
+                name=tool.get("name", ""),
+                kind="3",
+                start_ns=str(tool.get("start_ns", turn_start_ns)),
+                end_ns=str(tool.get("end_ns", turn_end_ns)),
+                attrs=tool.get("attributes", {}),
             )
         )
-        return 1
-
-    transcript_path = sys.argv[1]
-    turn_start_fallback = safe_int(sys.argv[2], 0) or None
-    expected_session_id = sys.argv[3] if len(sys.argv) > 3 else None
-
-    pending_raw = os.environ.get("PL_PENDING_TOOL_CALLS", "[]")
-    try:
-        pending_payloads = json.loads(pending_raw)
-    except Exception:
-        pending_payloads = []
-    if not isinstance(pending_payloads, list):
-        pending_payloads = []
-
-    parsed = parse_transcript(transcript_path, turn_start_fallback, pending_payloads, expected_session_id)
-    print(json.dumps(parsed, ensure_ascii=False, separators=(",", ":")))
-    return 0
 
+    for llm in parsed.get("llms", []):
+        span_specs.append(
+            SpanSpec(
+                trace_id=trace_id,
+                span_id=generate_span_id(),
+                parent_span_id=session_span_id,
+                name=llm.get("name", ""),
+                kind="3",
+                start_ns=str(llm.get("start_ns", turn_start_ns)),
+                end_ns=str(llm.get("end_ns", turn_end_ns)),
+                attrs=llm.get("attributes", {}),
+            )
+        )
 
-if __name__ == "__main__":
-    raise SystemExit(main())
+    return span_specs

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

@@ -0,0 +1,31 @@
+def parse_traceparent(raw: str):
+    if not raw:
+        return None
+
+    parts = raw.lower().split("-")
+    if len(parts) < 4:
+        return None
+
+    version, trace_id, parent_span_id, trace_flags = parts[:4]
+    suffix = parts[4:]
+
+    if len(version) != 2 or len(trace_id) != 32 or len(parent_span_id) != 16 or len(trace_flags) != 2:
+        return None
+
+    hexdigits = set("0123456789abcdef")
+    if any(ch not in hexdigits for ch in version + trace_id + parent_span_id + trace_flags):
+        return None
+    if version == "ff":
+        return None
+    if version == "00" and suffix:
+        return None
+    if trace_id == "0" * 32 or parent_span_id == "0" * 16:
+        return None
+
+    return {
+        "version": version,
+        "trace_id": trace_id,
+        "parent_span_id": parent_span_id,
+        "trace_flags": trace_flags,
+        "source": "external_traceparent",
+    }

package/vendor/claude-agents/trace/hooks/session_end.sh

@@ -9,29 +9,7 @@ tracing_enabled || exit 0
 check_requirements || exit 0
 
 input="$(cat)"
-session_id="$(echo "$input" | jq -r '.session_id // empty')"
+session_id="$(printf '%s' "$input" | python3 "$SCRIPT_DIR/py/cli.py" session-end)"
 [[ -z "$session_id" ]] && exit 0
 
-acquire_session_lock "$session_id" || exit 0
-trap 'release_session_lock' EXIT
-
-trace_id="$(get_session_state "$session_id" trace_id)"
-session_span_id="$(get_session_state "$session_id" session_span_id)"
-session_parent_span_id="$(get_session_state "$session_id" session_parent_span_id)"
-session_start_ns="$(get_session_state "$session_id" session_start_ns)"
-[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
-[[ -z "$session_start_ns" ]] && session_start_ns="$(now_ns)"
-
-release_session_lock
-trap - EXIT
-
-# Always emit/re-emit root span with final end time. The server upserts on
-# span_id conflict, so this safely updates the end time and lifecycle attribute.
-end_ns="$(now_ns)"
-attrs='{"source":"claude-code","hook":"SessionEnd","node_type":"WORKFLOW","session.lifecycle":"complete"}'
-emit_span "$trace_id" "$session_span_id" "$session_parent_span_id" "Claude Code session" "1" "$session_start_ns" "$end_ns" "$attrs" || true
-
-acquire_session_lock "$session_id" || exit 0
-trap 'release_session_lock' EXIT
-rm -f "$PL_SESSION_STATE_DIR/$session_id.json"
 log "INFO" "SessionEnd finalized session_id=$session_id"

package/vendor/claude-agents/trace/hooks/session_start.sh

@@ -9,49 +9,13 @@ tracing_enabled || exit 0
 check_requirements || exit 0
 
 input="$(cat)"
-session_id="$(echo "$input" | jq -r '.session_id // empty')"
-[[ -z "$session_id" ]] && session_id="$(uuidgen | tr '[:upper:]' '[:lower:]')"
+result="$(printf '%s' "$input" | python3 "$SCRIPT_DIR/py/cli.py" session-start)"
+IFS=$'\t' read -r session_id trace_id status <<<"$result"
+[[ -z "$session_id" ]] && exit 0
 
-existing_trace_id="$(get_session_state "$session_id" trace_id)"
-existing_session_span_id="$(get_session_state "$session_id" session_span_id)"
-if [[ -n "$existing_trace_id" && -n "$existing_session_span_id" ]]; then
-	if [[ -z "$(get_session_state "$session_id" session_start_ns)" ]]; then
-		set_session_state "$session_id" session_start_ns "$(now_ns)"
-	fi
-	if [[ -z "$(get_session_state "$session_id" pending_tool_calls)" ]]; then
-		set_session_state "$session_id" pending_tool_calls "[]"
-	fi
-	if [[ -z "$(get_session_state "$session_id" session_parent_span_id)" ]]; then
-		set_session_state "$session_id" session_parent_span_id ""
-	fi
-	if [[ -z "$(get_session_state "$session_id" session_traceparent_version)" ]]; then
-		set_session_state "$session_id" session_traceparent_version ""
-	fi
-	if [[ -z "$(get_session_state "$session_id" session_trace_flags)" ]]; then
-		set_session_state "$session_id" session_trace_flags ""
-	fi
-	if [[ -z "$(get_session_state "$session_id" trace_context_source)" ]]; then
-		set_session_state "$session_id" trace_context_source "generated"
-	fi
-	log "INFO" "SessionStart ignored existing state session_id=$session_id trace_id=$existing_trace_id"
+if [[ "$status" == "existing" ]]; then
+	log "INFO" "SessionStart ignored existing state session_id=$session_id trace_id=$trace_id"
 	exit 0
 fi
 
-load_initial_trace_context || true
-trace_id="${PL_INITIAL_TRACE_ID:-}"
-[[ -z "$trace_id" ]] && trace_id="$(generate_trace_id)"
-span_id="$(generate_span_id)"
-start_ns="$(now_ns)"
-
-set_session_state "$session_id" trace_id "$trace_id"
-set_session_state "$session_id" session_span_id "$span_id"
-set_session_state "$session_id" session_parent_span_id "${PL_INITIAL_PARENT_SPAN_ID:-}"
-set_session_state "$session_id" session_start_ns "$start_ns"
-set_session_state "$session_id" current_turn_start_ns ""
-set_session_state "$session_id" pending_tool_calls "[]"
-set_session_state "$session_id" session_init_source "session_start_hook"
-set_session_state "$session_id" session_traceparent_version "${PL_INITIAL_TRACEPARENT_VERSION:-}"
-set_session_state "$session_id" session_trace_flags "${PL_INITIAL_TRACE_FLAGS:-}"
-set_session_state "$session_id" trace_context_source "${PL_INITIAL_TRACE_CONTEXT_SOURCE:-generated}"
-
 log "INFO" "SessionStart captured session_id=$session_id trace_id=$trace_id"

package/vendor/claude-agents/trace/hooks/stop_hook.sh

@@ -9,115 +9,12 @@ tracing_enabled || exit 0
 check_requirements || exit 0
 
 input="$(cat)"
-session_id="$(echo "$input" | jq -r '.session_id // empty')"
-transcript_path="$(echo "$input" | jq -r '.transcript_path // empty')"
-
-if [[ -z "$session_id" && -n "$transcript_path" ]]; then
-	session_id="$(basename "$transcript_path" .jsonl)"
-fi
+result="$(printf '%s' "$input" | python3 "$SCRIPT_DIR/py/cli.py" stop-hook)"
+IFS=$'\t' read -r session_id status <<<"$result"
 [[ -z "$session_id" ]] && exit 0
-spans_file="$(mktemp "${TMPDIR:-/tmp}/pl-stop-spans.XXXXXX")"
-cleanup() {
-	rm -f "$spans_file"
-	release_session_lock
-}
-trap cleanup EXIT
-
-add_span_to_batch() {
-	local trace="$1"
-	local span="$2"
-	local parent="$3"
-	local span_name="$4"
-	local span_kind="$5"
-	local start="$6"
-	local end="$7"
-	local attrs="$8"
-
-	local span_json
-	span_json="$(build_span_json "$trace" "$span" "$parent" "$span_name" "$span_kind" "$start" "$end" "$attrs")" || return 1
-	printf '%s\n' "$span_json" >>"$spans_file"
-}
-
-acquire_session_lock "$session_id" || exit 0
-ensure_session_initialized "$session_id"
-
-trace_id="$(get_session_state "$session_id" trace_id)"
-session_span_id="$(get_session_state "$session_id" session_span_id)"
-session_parent_span_id="$(get_session_state "$session_id" session_parent_span_id)"
-turn_start_ns="$(get_session_state "$session_id" current_turn_start_ns)"
-pending_tool_calls="$(get_session_state "$session_id" pending_tool_calls)"
-session_init_source="$(get_session_state "$session_id" session_init_source)"
-session_start_ns="$(get_session_state "$session_id" session_start_ns)"
-
-[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
-[[ -z "$pending_tool_calls" ]] && pending_tool_calls='[]'
-[[ -z "$session_start_ns" ]] && session_start_ns="$(now_ns)"
-
-[[ -z "$turn_start_ns" ]] && turn_start_ns="$(now_ns)"
 
-# Keep lock scope short: snapshot + clear turn-specific mutable state.
-set_session_state "$session_id" current_turn_start_ns ""
-set_session_state "$session_id" pending_tool_calls "[]"
-
-release_session_lock
-
-parse_transcript_with_retry() {
-	local attempts=0
-	local parsed llm_count
-	while true; do
-		parsed="$(PL_PENDING_TOOL_CALLS="$pending_tool_calls" python3 "$SCRIPT_DIR/parse_stop_transcript.py" "$transcript_path" "$turn_start_ns" "$session_id")"
-		llm_count="$(echo "$parsed" | jq -r '.llms | length')"
-		if [[ "$llm_count" -gt 0 || $attempts -ge 10 ]]; then
-			echo "$parsed"
-			return 0
-		fi
-		attempts=$((attempts + 1))
-		sleep 0.2
-	done
-}
-
-if [[ -z "$transcript_path" || ! -f "$transcript_path" ]]; then
+if [[ "$status" == "missing_transcript" ]]; then
 	log "WARN" "Stop missing transcript session_id=$session_id"
-else
-	parsed="$(parse_transcript_with_retry)"
-
-	turn_start_ns="$(echo "$parsed" | jq -r '.turn.start_ns')"
-	turn_end_ns="$(echo "$parsed" | jq -r '.turn.end_ns')"
-
-	# Emit (or re-emit) the root session span eagerly so the trace is visible
-	# in the UI before the session ends. The server upserts on span_id conflict,
-	# so re-emitting with an updated end time is safe.
-	if [[ "$session_init_source" == "lazy_init" ]]; then
-		session_hook_attr="StopFallback"
-		session_lifecycle_attr="stop_fallback"
-	else
-		session_hook_attr="Stop"
-		session_lifecycle_attr="in_progress"
-	fi
-	session_attrs="{\"source\":\"claude-code\",\"hook\":\"$session_hook_attr\",\"node_type\":\"WORKFLOW\",\"session.lifecycle\":\"$session_lifecycle_attr\"}"
-	add_span_to_batch "$trace_id" "$session_span_id" "$session_parent_span_id" "Claude Code session" "1" "$session_start_ns" "$turn_end_ns" "$session_attrs" || true
-
-	while IFS= read -r tool; do
-		[[ -z "$tool" ]] && continue
-		span_id="$(generate_span_id)"
-		name="$(echo "$tool" | jq -r '.name')"
-		start_ns="$(echo "$tool" | jq -r '.start_ns')"
-		end_ns="$(echo "$tool" | jq -r '.end_ns')"
-		attrs="$(echo "$tool" | jq -c '.attributes')"
-		add_span_to_batch "$trace_id" "$span_id" "$session_span_id" "$name" "3" "$start_ns" "$end_ns" "$attrs" || true
-	done < <(echo "$parsed" | jq -c '.tools[]?')
-
-	while IFS= read -r llm; do
-		[[ -z "$llm" ]] && continue
-		span_id="$(generate_span_id)"
-		name="$(echo "$llm" | jq -r '.name')"
-		start_ns="$(echo "$llm" | jq -r '.start_ns')"
-		end_ns="$(echo "$llm" | jq -r '.end_ns')"
-		attrs="$(echo "$llm" | jq -c '.attributes')"
-		add_span_to_batch "$trace_id" "$span_id" "$session_span_id" "$name" "3" "$start_ns" "$end_ns" "$attrs" || true
-	done < <(echo "$parsed" | jq -c '.llms[]?')
 fi
 
-emit_spans_batch_file "$spans_file" || true
-
 log "INFO" "Stop finalized session_id=$session_id"

package/vendor/claude-agents/trace/hooks/user_prompt_submit.sh

@@ -9,17 +9,7 @@ tracing_enabled || exit 0
 check_requirements || exit 0
 
 input="$(cat)"
-session_id="$(echo "$input" | jq -r '.session_id // empty')"
+session_id="$(printf '%s' "$input" | python3 "$SCRIPT_DIR/py/cli.py" user-prompt-submit)"
 [[ -z "$session_id" ]] && exit 0
 
-ensure_session_initialized "$session_id"
-
-trace_id="$(get_session_state "$session_id" trace_id)"
-session_span_id="$(get_session_state "$session_id" session_span_id)"
-[[ -z "$trace_id" || -z "$session_span_id" ]] && exit 0
-start_ns="$(now_ns)"
-
-set_session_state "$session_id" current_turn_start_ns "$start_ns"
-set_session_state "$session_id" pending_tool_calls "[]"
-
 log "INFO" "UserPromptSubmit captured session_id=$session_id"