pi-langfuse 1.5.13 → 1.5.15

package/README.md

@@ -108,8 +108,11 @@ export LANGFUSE_CAPTURE_OUTPUTS=true
 export LANGFUSE_CAPTURE_TOOL_IO=false
 export LANGFUSE_CAPTURE_SYSTEM_PROMPT=false
 export LANGFUSE_CAPTURE_CWD=false
+export LANGFUSE_CAPTURE_SOURCE_METADATA=false
 ```
 
+Source metadata remains off in every preset unless `LANGFUSE_CAPTURE_SOURCE_METADATA=true` is set explicitly.
+
 All captured payloads are redacted before upload. The extension masks common API keys, bearer tokens, passwords, cookies, private keys, Langfuse keys, GitHub/npm/AWS-style tokens, and local absolute paths.
 
 ### Payload limits
@@ -133,6 +136,19 @@ defaults shown above. To capture a very large system prompt or big tool
 payloads in full, raise or disable the relevant limit (e.g.
 `PI_LANGFUSE_MAX_STRING_LENGTH=off`).
 
+The REST fallback ingestion is chunked so each request body stays well below
+the Langfuse gateway's payload limit (~4.5MB). These knobs control the chunk
+budget and a hard ceiling for the whole fallback payload:
+
+```bash
+export PI_LANGFUSE_MAX_INGESTION_BATCH_BYTES=4194304  # per-request body budget, default 4MB
+
+export PI_LANGFUSE_MAX_FALLBACK_TOTAL_BYTES=33554432  # whole-payload ceiling, default 32MB
+```
+
+When the accumulated fallback payload exceeds the 32MB ceiling, ingestion is
+skipped with a warning instead of attempting an unrecoverably large upload.
+
 ### Method 3: Persistent `config.json`
 
 Create or update `~/.pi/agent/pi-langfuse/config.json`:
@@ -198,50 +214,44 @@ The package also includes a Langfuse CLI skill, so Langfuse data can be queried
 
 ## Source Metadata
 
-Local prototype note: source metadata support in this installed package is a local prototype patch. A durable solution should be shipped through an upstream PR, a fork, or a maintained package version so reinstalling the extension does not lose the behavior.
+Repository source capture is independent of the privacy presets and disabled by default. Enable it only after deciding that commit identity is appropriate for the Langfuse project:
+
+```bash
+export LANGFUSE_CAPTURE_SOURCE_METADATA=true
+```
 
-For Git-backed runs, the extension attaches safe source metadata to traces:
+For a Git worktree, the extension records only revision state:
 
 ```json
 {
   "source_type": "git-repo",
-  "repo_identity": "owner/repo",
-  "repo_owner": "owner",
-  "repo_name": "repo",
-  "repo_root_name": "repo",
-  "git_branch": "main",
-  "git_commit": "abc123",
-  "git_remote_host": "github.com",
-  "git_remote_path": "owner/repo",
+  "vcs.ref.head.revision": "0123456789abcdef...",
+  "git_detached": "false",
+  "git_dirty": "false",
   "metadata_source": "git-detection"
 }
 ```
 
-`repo_identity` is `owner/repo`. `repo_name` is the repo name only and must not contain a slash.
+The revision is the full `HEAD` commit. Dirty state includes tracked changes and untracked files, but never their paths or contents. Detached state is reported without a branch or tag name. Git remotes, URLs, credentials, usernames, branches, absolute paths, and repository names are never inspected or uploaded by this collector.
 
-A Git repo may optionally provide `.pi-langfuse.metadata.json`. Overrides are whitelist-only; unknown keys are ignored. Allowed keys are:
+When capture is off, the collector does not invoke Git and reports `source_type: "disabled"`. Non-Git directories report `non-git`; a missing or unusable Git executable and incomplete Git state report `unavailable`.
 
-```text
-repo_identity
-repo_owner
-repo_name
-source_type
-service_name
-project_slug
-environment
-observability_owner
+Use native Langfuse and OpenTelemetry settings for deployment identity and explicit operator-owned overrides instead of repository files:
+
+```bash
+export LANGFUSE_RELEASE="1.2.3"
+export LANGFUSE_TRACING_ENVIRONMENT="production"
+export OTEL_SERVICE_NAME="pi-agent"
+export OTEL_RESOURCE_ATTRIBUTES="service.version=1.2.3,vcs.repository.name=public-repo"
 ```
 
-Repo-local overrides are used only after the working directory is confirmed to be inside a usable Git repo. If Git detection fails for any reason, including a missing Git command, corrupted repo, or non-Git folder, the extension ignores repo-local identity files and emits only:
+`LANGFUSE_RELEASE` and `LANGFUSE_TRACING_ENVIRONMENT` keep their Langfuse semantics. `OTEL_SERVICE_NAME` and `OTEL_RESOURCE_ATTRIBUTES` are loaded as process-scoped OpenTelemetry resource attributes; values such as `vcs.repository.name` apply to every session sharing the runtime, may identify private source, and require a runtime restart to change.
 
-```json
-{
-  "source_type": "non-git",
-  "metadata_source": "non-git"
-}
-```
+### Compatibility and rollback
+
+Earlier versions emitted `git_commit`, branch, remote, owner, repository, and repo-local `.pi-langfuse.metadata.json` values by default. New traces use `vcs.ref.head.revision` and stop reading that file. Update dashboards before enabling source capture; historical traces are unchanged.
 
-The extension must not upload raw absolute local paths, credentialed remotes, tokens, unknown override keys, or folder names for non-Git folders.
+Unset `LANGFUSE_CAPTURE_SOURCE_METADATA` to stop collection immediately. Pin `pi-langfuse@1.5.12` only if the old schema is required during migration; doing so also restores its broader default source disclosure.
 
 ## Troubleshooting
 

package/README_CN.md

@@ -108,10 +108,41 @@ export LANGFUSE_CAPTURE_OUTPUTS=true
 export LANGFUSE_CAPTURE_TOOL_IO=false
 export LANGFUSE_CAPTURE_SYSTEM_PROMPT=false
 export LANGFUSE_CAPTURE_CWD=false
+export LANGFUSE_CAPTURE_SOURCE_METADATA=false
 ```
 
+所有隐私预设默认都关闭源码元数据；只有显式设置 `LANGFUSE_CAPTURE_SOURCE_METADATA=true` 才会启用。
+
 所有被采集的负载在上传前仍会脱敏。扩展会隐藏常见 API key、Bearer token、密码、Cookie、私钥、Langfuse key、GitHub/npm/AWS 风格 token，并对本地绝对路径做 hash。
 
+### 负载上限
+
+上传前会对负载做整形：字符串会被截断，过深或过宽的结构会被裁剪。这些上限让 trace 保持精简，同时保护
+Langfuse 摄取管线。任何一项都可以覆盖（无需重新构建）：
+
+```bash
+export PI_LANGFUSE_MAX_STRING_LENGTH=12000       # 单字符串字符数（system prompt、输入）
+export PI_LANGFUSE_MAX_TOOL_PAYLOAD_LENGTH=24000 # 工具输入/输出字符数
+export PI_LANGFUSE_MAX_DEPTH=6                    # 最大嵌套深度
+export PI_LANGFUSE_MAX_ARRAY_ITEMS=50            # 数组保留的最大元素数
+export PI_LANGFUSE_MAX_OBJECT_KEYS=80            # 对象保留的最大键数
+export PI_LANGFUSE_MAX_PAYLOAD_NODES=2000        # 单个负载的最大总节点数
+```
+
+任意上限设置为 `0`、`off`、`none` 或 `unlimited` 即表示关闭该限制（采集完整值）；未设置或非法值回退到上方默认值。
+若想完整采集很大的 system prompt 或工具负载，可以调高或关闭相关限制（例如 `PI_LANGFUSE_MAX_STRING_LENGTH=off`）。
+
+REST 回退摄取会按字节切分，保证每个请求体都远低于 Langfuse 网关的负载限制（约 4.5MB）。以下变量控制切分预算
+与整个回退负载的硬上限：
+
+```bash
+export PI_LANGFUSE_MAX_INGESTION_BATCH_BYTES=4194304  # 单次请求体预算，默认 4MB
+
+export PI_LANGFUSE_MAX_FALLBACK_TOTAL_BYTES=33554432  # 整体负载上限，默认 32MB
+```
+
+当累积的回退负载超过 32MB 上限时，会跳过摄取并给出告警，而不是尝试一次注定失败的超大上传。
+
 ### 方式 3：持久化 `config.json`
 
 创建或更新 `~/.pi/agent/pi-langfuse/config.json`：
@@ -175,6 +206,47 @@ pi list
 /pi-langfuse-langfuse <查询内容>
 ```
 
+## 源码元数据
+
+仓库源码采集独立于隐私预设，默认关闭。只有在确认提交标识适合写入当前 Langfuse 项目后才启用：
+
+```bash
+export LANGFUSE_CAPTURE_SOURCE_METADATA=true
+```
+
+对于 Git 工作树，扩展只记录修订状态：
+
+```json
+{
+  "source_type": "git-repo",
+  "vcs.ref.head.revision": "0123456789abcdef...",
+  "git_detached": "false",
+  "git_dirty": "false",
+  "metadata_source": "git-detection"
+}
+```
+
+修订值为完整的 `HEAD` 提交。dirty 状态包含已跟踪变更和未跟踪文件，但绝不包含路径或内容。detached 状态不会附带分支名或标签名。此采集器不会检查或上传 Git remote、URL、凭据、用户名、分支、绝对路径或仓库名。
+
+关闭采集时，扩展不会调用 Git，并报告 `source_type: "disabled"`。非 Git 目录报告 `non-git`；Git 不可用或仓库状态不完整时报告 `unavailable`。
+
+部署标识和显式覆盖应使用 Langfuse 与 OpenTelemetry 原生配置，而不是仓库文件：
+
+```bash
+export LANGFUSE_RELEASE="1.2.3"
+export LANGFUSE_TRACING_ENVIRONMENT="production"
+export OTEL_SERVICE_NAME="pi-agent"
+export OTEL_RESOURCE_ATTRIBUTES="service.version=1.2.3,vcs.repository.name=public-repo"
+```
+
+`LANGFUSE_RELEASE` 与 `LANGFUSE_TRACING_ENVIRONMENT` 保持 Langfuse 原生语义。`OTEL_SERVICE_NAME` 和 `OTEL_RESOURCE_ATTRIBUTES` 会作为进程级 OpenTelemetry resource attributes 加载；`vcs.repository.name` 等值会应用到共享同一 runtime 的所有会话，可能暴露私有源码身份，而且修改后需要重启 runtime。
+
+### 兼容与回滚
+
+旧版本默认发送 `git_commit`、分支、remote、owner、仓库名及 `.pi-langfuse.metadata.json` 中的值。新 trace 改用 `vcs.ref.head.revision`，并停止读取该文件。启用源码采集前应更新 dashboard；历史 trace 不受影响。
+
+取消设置 `LANGFUSE_CAPTURE_SOURCE_METADATA` 可立即停止采集。迁移期间只有在必须保留旧 schema 时才固定到 `pi-langfuse@1.5.12`；这样也会恢复旧版本更宽泛的默认源码披露。
+
 ## 故障排除
 
 ### 没有看到 trace

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-langfuse",
-	"version": "1.5.13",
+	"version": "1.5.15",
 	"description": "Langfuse extension for Pi coding agent",
 	"repository": {
 		"type": "git",

package/src/capture-policy.ts

@@ -1,4 +1,4 @@
-import { redactValue } from "./redaction.js";
+import { hashPath, redactValue } from "./redaction.js";
 
 export interface CapturePolicy {
   readonly captureInputs: boolean;
@@ -6,6 +6,7 @@ export interface CapturePolicy {
   readonly captureToolIo: boolean;
   readonly captureSystemPrompt: boolean;
   readonly captureCwd: boolean;
+  readonly captureSourceMetadata: boolean;
 }
 
 export type PrivacyPreset = "metadata-only" | "prompts-only" | "conversations" | "full-debug";
@@ -36,6 +37,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureToolIo: false,
     captureSystemPrompt: false,
     captureCwd: false,
+    captureSourceMetadata: false,
   },
   "prompts-only": {
     captureInputs: true,
@@ -43,6 +45,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureToolIo: false,
     captureSystemPrompt: false,
     captureCwd: false,
+    captureSourceMetadata: false,
   },
   conversations: {
     captureInputs: true,
@@ -50,6 +53,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureToolIo: false,
     captureSystemPrompt: false,
     captureCwd: false,
+    captureSourceMetadata: false,
   },
   "full-debug": {
     captureInputs: true,
@@ -57,6 +61,7 @@ const PRESETS: Record<PrivacyPreset, CapturePolicy> = {
     captureToolIo: true,
     captureSystemPrompt: true,
     captureCwd: true,
+    captureSourceMetadata: false,
   },
 };
 
@@ -66,6 +71,7 @@ const FLAG_TO_FIELD = {
   LANGFUSE_CAPTURE_TOOL_IO: "captureToolIo",
   LANGFUSE_CAPTURE_SYSTEM_PROMPT: "captureSystemPrompt",
   LANGFUSE_CAPTURE_CWD: "captureCwd",
+  LANGFUSE_CAPTURE_SOURCE_METADATA: "captureSourceMetadata",
 } as const;
 
 function parseFlag(value: string | undefined): boolean | undefined {
@@ -105,7 +111,13 @@ function redactMetadata(metadata: Record<string, unknown> | undefined, policy: C
 
   const output: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(metadata)) {
-    if (key === "cwd" && !policy.captureCwd) {
+    if (key === "cwd") {
+      if (!policy.captureCwd) {
+        continue;
+      }
+      output[key] = typeof value === "string" && /^(?:\/|[A-Za-z]:[\\/]|\\\\)/.test(value)
+        ? hashPath(value)
+        : redactValue(value);
       continue;
     }
     output[key] = redactValue(value);

package/src/commands.ts

@@ -75,7 +75,7 @@ function isPrivacyPreset(value: string | undefined): value is PrivacyPreset {
 }
 
 function inferPreset(policy: CapturePolicy): PrivacyPreset | "custom" {
-  const entries: Array<[PrivacyPreset, CapturePolicy]> = [
+  const entries: Array<[PrivacyPreset, Omit<CapturePolicy, "captureSourceMetadata">]> = [
     [
       "metadata-only",
       {
@@ -139,6 +139,7 @@ function describePolicy(policy: CapturePolicy) {
     `captureToolIo: ${policy.captureToolIo}`,
     `captureSystemPrompt: ${policy.captureSystemPrompt}`,
     `captureCwd: ${policy.captureCwd}`,
+    `captureSourceMetadata: ${policy.captureSourceMetadata}`,
   ].join("\n");
 }
 

package/src/handlers/agent.ts

@@ -59,7 +59,8 @@ export async function startAgentRun(event: Record<string, unknown>, ctx: any) {
       images: event.images,
       context: event.context ?? event.attachments,
     });
-    const sourceMetadata = collectSourceMetadata(cwd);
+    const capturePolicy = getCapturePolicy();
+    const sourceMetadata = collectSourceMetadata(cwd, capturePolicy.captureSourceMetadata);
     const captured = applyCapturePolicy(
       {
         input: rawPromptInput,
@@ -71,7 +72,7 @@ export async function startAgentRun(event: Record<string, unknown>, ctx: any) {
           sessionId: state.currentSessionId || undefined,
         },
       },
-      getCapturePolicy(),
+      capturePolicy,
     );
 
     state.agentState = {

package/src/langfuse.ts

@@ -69,6 +69,13 @@ const DEFAULT_SCORE_FLUSH_AT = 10;
 const DEFAULT_SCORE_FLUSH_INTERVAL_MS = 1_000;
 const MAX_SCORE_QUEUE_SIZE = 100_000;
 const MAX_SCORE_BATCH_SIZE = 100;
+// Langfuse gateways (incl. langfuse-dx.wair.ac.cn) reject ingestion bodies above
+// ~4.5MB with HTTP 413. Keep the default chunk budget safely below that limit.
+const DEFAULT_MAX_INGESTION_BATCH_BYTES = 4 * 1024 * 1024;
+// Hard ceiling for the whole REST fallback payload. Above this the fallback is
+// pointless (it would need dozens of requests during a bounded shutdown) and is
+// skipped with a warning.
+const DEFAULT_MAX_FALLBACK_TOTAL_BYTES = 32 * 1024 * 1024;
 
 let shutdownStepTimeoutMs = DEFAULT_SHUTDOWN_STEP_TIMEOUT_MS;
 
@@ -91,6 +98,22 @@ function getScoreShutdownTimeoutMs(): number {
   ) * 1_000;
 }
 
+function getMaxIngestionBatchBytes(): number {
+  return resolvePositiveEnvNumber(
+    "PI_LANGFUSE_MAX_INGESTION_BATCH_BYTES",
+    DEFAULT_MAX_INGESTION_BATCH_BYTES,
+    true,
+  );
+}
+
+function getMaxFallbackTotalBytes(): number {
+  return resolvePositiveEnvNumber(
+    "PI_LANGFUSE_MAX_FALLBACK_TOTAL_BYTES",
+    DEFAULT_MAX_FALLBACK_TOTAL_BYTES,
+    true,
+  );
+}
+
 function delay(ms: number, signal?: AbortSignal) {
   return new Promise<void>((resolve, reject) => {
     if (signal?.aborted) {
@@ -244,6 +267,41 @@ async function ingestBatch(rt: LangfuseRuntime, batch: unknown[], signal: AbortS
   return Array.isArray(responseBody.errors) ? responseBody.errors : [];
 }
 
+function serializedBytes(value: unknown): number {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+/**
+ * Split an ingestion event list into chunks whose serialized request bodies each
+ * stay under `maxBytes`. Each chunk, when wrapped as `{ batch: chunk }`, matches
+ * the measurement exactly because entries are serialized individually and joined
+ * with single commas inside the `{"batch":[...]}` envelope.
+ */
+export function splitIngestionBatch(entries: unknown[], maxBytes: number): unknown[][] {
+  const serialized = entries.map((entry) => JSON.stringify(entry));
+  const envelopeBytes = Buffer.byteLength('{"batch":[]}');
+  const chunks: unknown[][] = [];
+  let chunk: unknown[] = [];
+  let chunkBytes = envelopeBytes;
+
+  for (let index = 0; index < serialized.length; index++) {
+    const entryBytes = Buffer.byteLength(serialized[index], "utf8");
+    const separators = chunk.length > 0 ? 1 : 0;
+    const projectedBytes = chunkBytes + entryBytes + separators;
+    if (chunk.length > 0 && projectedBytes > maxBytes) {
+      chunks.push(chunk);
+      chunk = [];
+      chunkBytes = envelopeBytes;
+    }
+    chunk.push(entries[index]);
+    chunkBytes += entryBytes + (chunk.length > 1 ? 1 : 0);
+  }
+  if (chunk.length > 0) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
 async function flushPendingScores(rt: LangfuseRuntime, signal: AbortSignal): Promise<void> {
   const pendingScores = rt.pendingScores;
   if (!pendingScores || pendingScores.length === 0) {
@@ -587,7 +645,7 @@ async function fallbackToRestIngestion(rt: LangfuseRuntime, signal: AbortSignal)
   }
 
   const trace = store.trace;
-  const batch: any[] = [
+  const entries: any[] = [
     {
       type: "trace-create",
       id: randomUUID(),
@@ -627,7 +685,7 @@ async function fallbackToRestIngestion(rt: LangfuseRuntime, signal: AbortSignal)
           }
         : {}),
     };
-    batch.push({
+    entries.push({
       type: observation.type === "GENERATION" ? "generation-create" : "span-create",
       id: randomUUID(),
       timestamp: eventTimestamp(observation),
@@ -635,12 +693,39 @@ async function fallbackToRestIngestion(rt: LangfuseRuntime, signal: AbortSignal)
     });
   }
 
-  const errors = await ingestBatch(rt, batch, signal);
+  const maxTotalBytes = getMaxFallbackTotalBytes();
+  const totalBytes = serializedBytes({ batch: entries });
+  if (totalBytes > maxTotalBytes) {
+    const message = `REST fallback payload is ${(totalBytes / 1024 / 1024).toFixed(1)}MB, above the ${(maxTotalBytes / 1024 / 1024).toFixed(1)}MB ceiling; skipping fallback ingestion`;
+    rememberRuntimeError("REST fallback ingestion", new Error(message));
+    console.warn(`📊 Langfuse: ${message}`);
+    return;
+  }
+
+  const chunks = splitIngestionBatch(entries, getMaxIngestionBatchBytes());
+  const errors: unknown[] = [];
+  for (const chunk of chunks) {
+    if (signal.aborted) {
+      break;
+    }
+    try {
+      errors.push(...(await ingestBatch(rt, chunk, signal)));
+    } catch (error) {
+      if (signal.aborted && isAbortError(error)) {
+        break;
+      }
+      rememberRuntimeError("REST fallback ingestion", error);
+      console.warn("📊 Langfuse: REST fallback ingestion chunk failed", error);
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
   if (errors.length > 0) {
     rememberRuntimeError("REST fallback ingestion", new Error(JSON.stringify(errors)));
     console.warn("📊 Langfuse: REST fallback ingestion reported errors", errors);
   } else {
-    debugLog(`📊 Langfuse: OTel trace ${trace.id} was not visible; wrote fallback trace via REST ingestion`);
+    debugLog(
+      `📊 Langfuse: OTel trace ${trace.id} was not visible; wrote fallback trace via REST ingestion (${chunks.length} chunk(s))`,
+    );
   }
 }
 
@@ -660,6 +745,7 @@ export async function getRuntime(): Promise<LangfuseRuntime> {
   if (!runtime) {
     const [
       { BasicTracerProvider },
+      { resources },
       { context },
       { AsyncHooksContextManager },
       { LangfuseSpanProcessor },
@@ -667,6 +753,7 @@ export async function getRuntime(): Promise<LangfuseRuntime> {
       { LangfuseClient },
     ] = await Promise.all([
       import("@opentelemetry/sdk-trace-base"),
+      import("@opentelemetry/sdk-node"),
       import("@opentelemetry/api"),
       import("@opentelemetry/context-async-hooks"),
       import("@langfuse/otel"),
@@ -692,7 +779,10 @@ export async function getRuntime(): Promise<LangfuseRuntime> {
         secretKey: state.config.secretKey,
         baseUrl: state.config.host,
       });
-      const tracerProvider = new BasicTracerProvider({ spanProcessors: [spanProcessor] });
+      const resource = resources.defaultResource().merge(
+        resources.detectResources({ detectors: [resources.envDetector] }),
+      );
+      const tracerProvider = new BasicTracerProvider({ resource, spanProcessors: [spanProcessor] });
       tracing.setLangfuseTracerProvider(tracerProvider);
 
       runtime = {

package/src/source-metadata.ts

@@ -1,160 +1,73 @@
-import { existsSync, readFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
 import { execFileSync } from "node:child_process";
 
 export type SourceMetadata = Record<string, string>;
 
-const OVERRIDE_KEYS = new Set([
-  "repo_identity",
-  "repo_owner",
-  "repo_name",
-  "source_type",
-  "service_name",
-  "project_slug",
-  "environment",
-  "observability_owner",
-]);
+type GitResult =
+  | { status: "ok"; value: string }
+  | { status: "failed" }
+  | { status: "unavailable" };
 
-function nonGitMetadata(): SourceMetadata {
+function sourceStatus(status: "disabled" | "non-git" | "unavailable"): SourceMetadata {
   return {
-    source_type: "non-git",
-    metadata_source: "non-git",
+    source_type: status,
+    metadata_source: status,
   };
 }
 
-function runGit(cwd: string, args: string[]): string {
-  return execFileSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: 2000,
-  }).trim();
-}
-
-function firstLine(value: string): string {
-  return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
-}
-
-export function sanitizeGitRemote(remoteUrl: string): Partial<Pick<SourceMetadata, "git_remote_host" | "git_remote_path">> {
-  const raw = firstLine(remoteUrl).replace(/\.git$/i, "");
-  if (!raw) {
-    return {};
-  }
-
+function runGit(cwd: string, args: string[], env: NodeJS.ProcessEnv): GitResult {
   try {
-    const parsed = new URL(raw);
-    const path = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/i, "");
-    return parsed.hostname && path ? { git_remote_host: parsed.hostname, git_remote_path: path } : {};
-  } catch {
-    // Continue with scp-like SSH syntax, for example git@github.com:owner/repo.git.
-  }
-
-  const scpLike = raw.match(/^(?:[^@\s/:]+@)?([^:\s]+):(.+)$/);
-  if (scpLike) {
-    const host = scpLike[1];
-    const path = scpLike[2].replace(/^\/+/, "").replace(/\.git$/i, "");
-    return host && path && !path.includes("@") ? { git_remote_host: host, git_remote_path: path } : {};
-  }
-
-  return {};
-}
-
-function deriveIdentity(remotePath: string | undefined): Partial<Pick<SourceMetadata, "repo_identity" | "repo_owner" | "repo_name">> {
-  if (!remotePath) {
-    return {};
-  }
-  const parts = remotePath.split("/").filter(Boolean);
-  if (parts.length < 2) {
-    return {};
-  }
-  const repoName = parts[parts.length - 1];
-  const owner = parts[parts.length - 2];
-  if (!repoName || !owner || repoName.includes("/")) {
-    return {};
+    return {
+      status: "ok",
+      value: execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2000,
+      }).trim(),
+    };
+  } catch (error) {
+    const failure = error as NodeJS.ErrnoException & { status?: number | null };
+    return typeof failure.status === "number"
+      ? { status: "failed" }
+      : { status: "unavailable" };
   }
-  return {
-    repo_identity: `${owner}/${repoName}`,
-    repo_owner: owner,
-    repo_name: repoName,
-  };
 }
 
-function findRepoMetadataFile(cwd: string, gitRoot: string): string | undefined {
-  let current = cwd;
-  const root = gitRoot;
-  while (true) {
-    const candidate = join(current, ".pi-langfuse.metadata.json");
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-    if (current === root) {
-      break;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+export function collectSourceMetadata(
+  cwd: string,
+  enabled: boolean,
+  env: NodeJS.ProcessEnv = process.env,
+): SourceMetadata {
+  if (!enabled) {
+    return sourceStatus("disabled");
   }
-  return undefined;
-}
 
-function readWhitelistedOverrides(cwd: string, gitRoot: string): SourceMetadata {
-  const path = findRepoMetadataFile(cwd, gitRoot);
-  if (!path) {
-    return {};
+  const inside = runGit(cwd, ["rev-parse", "--is-inside-work-tree"], env);
+  if (inside.status === "unavailable") {
+    return sourceStatus("unavailable");
   }
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
-    const output: SourceMetadata = {};
-    for (const [key, value] of Object.entries(parsed)) {
-      if (OVERRIDE_KEYS.has(key) && typeof value === "string" && value.trim()) {
-        output[key] = value.trim();
-      }
-    }
-    if (output.repo_name?.includes("/")) {
-      delete output.repo_name;
-    }
-    return output;
-  } catch {
-    return {};
+  if (inside.status !== "ok" || inside.value !== "true") {
+    return sourceStatus("non-git");
   }
-}
-
-export function collectSourceMetadata(cwd: string): SourceMetadata {
-  try {
-    const inside = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-    if (inside !== "true") {
-      return nonGitMetadata();
-    }
-
-    const gitRoot = runGit(cwd, ["rev-parse", "--show-toplevel"]);
-    const commit = runGit(cwd, ["rev-parse", "HEAD"]);
-    const branch = runGit(cwd, ["branch", "--show-current"]);
-    const remote = runGit(cwd, ["config", "--get", "remote.origin.url"]);
-    const remoteMetadata = sanitizeGitRemote(remote);
-    const derivedIdentity = deriveIdentity(remoteMetadata.git_remote_path);
-    const overrides = readWhitelistedOverrides(cwd, gitRoot);
-
-    const metadata: SourceMetadata = {
-      source_type: "git-repo",
-      repo_root_name: basename(gitRoot),
-      ...(branch ? { git_branch: branch } : {}),
-      git_commit: commit,
-      ...remoteMetadata,
-      ...derivedIdentity,
-      ...overrides,
-      metadata_source: Object.keys(overrides).length > 0 ? "repo-file" : "git-detection",
-    };
 
-    if (metadata.repo_name?.includes("/")) {
-      delete metadata.repo_name;
-    }
-    if (!metadata.repo_identity && metadata.repo_owner && metadata.repo_name) {
-      metadata.repo_identity = `${metadata.repo_owner}/${metadata.repo_name}`;
-    }
-    return metadata;
-  } catch {
-    return nonGitMetadata();
+  const revision = runGit(cwd, ["rev-parse", "--verify", "HEAD"], env);
+  const ref = runGit(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], env);
+  const workingTree = runGit(cwd, ["status", "--porcelain=v1", "--untracked-files=normal"], env);
+  if (
+    revision.status !== "ok" ||
+    !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(revision.value) ||
+    workingTree.status !== "ok" ||
+    ref.status === "unavailable"
+  ) {
+    return sourceStatus("unavailable");
   }
+
+  return {
+    source_type: "git-repo",
+    "vcs.ref.head.revision": revision.value,
+    git_detached: String(ref.status !== "ok"),
+    git_dirty: String(Boolean(workingTree.value)),
+    metadata_source: "git-detection",
+  };
 }

package/types/langfuse-runtime-shims.d.ts

@@ -1,6 +1,6 @@
 declare module "@opentelemetry/sdk-trace-base" {
   export class BasicTracerProvider {
-    constructor(options?: { spanProcessors?: unknown[] });
+    constructor(options?: { resource?: unknown; spanProcessors?: unknown[] });
     forceFlush?(): Promise<void>;
     shutdown?(): Promise<void>;
   }