feat: enrich telemetry with pythonVersion and dbtCoreVersion customAttributes

Production telemetry currently carries `common.os` / `common.nodeArch` /
`common.extversion` etc. on every event but **not** the user's Python
interpreter version or installed dbt-core distribution version. That's a
real blindspot — App Insights can't split error clusters by Python
version (e.g. is `pythonBridgeInitPythonError "mashumaro
UnserializableField"` a Python 3.13 + mashumaro 3.14 incompat or
something else?) and we can't tell whether `catalogPythonError "missing
used_schemas"` correlates with a specific dbt-core minor.

Adds two customAttributes that get merged into every event going
forward via `TelemetryService.setTelemetryCustomAttribute`:

- `pythonVersion` — sourced from `PythonEnvironment.pythonVersion`
  (already populated via the VS Code Python extension's API on
  interpreter activation, no additional probe needed).
- `dbtCoreVersion` — sourced from a small `child_process.spawn` probe
  in `src/telemetry/versionProbes.ts` that runs
  `python -c "from importlib.metadata import version; print(version('dbt-core'))"`.
  Reads dist-info directly so it survives even when dbt's own import
  chain is broken (the failure mode PR #96 targeted) — the bridge can
  be dead and we still get the version.

Both are best-effort: probe failure → no customAttribute set rather
than blocking activation. Wired into `DBTPowerUserExtension.activate`
after `initializeDBTProjects` (when the Python interpreter is known)
plus a refresh on `pythonEnvironment.onPythonEnvironmentChanged` so the
dimensions track interpreter changes.

`probeDbtCoreVersion` accepts an injectable `SpawnFn` parameter
defaulted to `child_process.spawn`. `import * as childProcess` produces
ESM-style bindings that resist `jest.spyOn` / `jest.mock` redefinition
under ts-jest, so the tests pass their own spawner directly. Adds 6
unit tests covering: success, empty stdout (PackageNotFoundError),
non-zero exit, error event, sync throw, and timeout.

After this ships and rolls out, App Insights queries can split by
`customDimensions.pythonVersion == "3.13.0"` or
`customDimensions.dbtCoreVersion startswith "1.10"` on every event,
not just the wrapper-failure events. Dashboards become diagnostic by
construction without per-event injection.

Tests: 33 suites / 486 passed (32 prior + 1 new).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ralphstodomingo

package.json

@@ -1342,7 +1342,7 @@
     "altimateai.vscode-altimate-mcp-server"
   ],
   "dependencies": {
-    "@altimateai/dbt-integration": "^0.3.0",
+    "@altimateai/dbt-integration": "^0.3.1",
     "@jupyterlab/coreutils": "^6.2.4",
     "@jupyterlab/nbformat": "^4.2.4",
     "@jupyterlab/services": "^7.0.0",

src/dbtPowerUserExtension.ts

@@ -1,3 +1,4 @@
+import { probeDbtCoreVersion } from "@altimateai/dbt-integration";
 import { NotebookProviders } from "@lib";
 import { commands, Disposable, ExtensionContext, workspace } from "vscode";
 import { AutocompletionProviders } from "./autocompletion_provider";
@@ -41,6 +42,13 @@ export class DBTPowerUserExtension implements Disposable {
   ];
 
   private disposables: Disposable[] = [];
+  /**
+   * Monotonic sequence counter for `refreshVersionTelemetryAttributes` so
+   * a slow earlier invocation can't overwrite attributes written by a
+   * faster later one. Each refresh captures the seq at start and only
+   * applies its results if the seq still matches.
+   */
+  private versionRefreshSeq = 0;
 
   constructor(
     private dbtProjectContainer: DBTProjectContainer,
@@ -97,6 +105,34 @@ export class DBTPowerUserExtension implements Disposable {
       this.dbtProjectContainer.setContext(context);
       this.dbtProjectContainer.initializeWalkthrough();
       await this.dbtProjectContainer.detectDBT();
+
+      // Enrich every telemetry event with the active Python interpreter version
+      // and dbt-core dist version. Without these dimensions, App Insights can't
+      // split error clusters by Python or dbt-core version — e.g. we can't
+      // tell whether a `pythonBridgeInitPythonError "mashumaro
+      // UnserializableField"` is a Python 3.13 + mashumaro 3.14 incompat or
+      // something else. Both probes are best-effort: failure → attribute is
+      // cleared rather than blocking activation.
+      //
+      // Primed BEFORE `initializeDBTProjects()` because that call is the
+      // python-bridge init step where `pythonBridgeInitPythonError` itself
+      // originates. The `void`-fired refresh runs synchronously up to its
+      // first await, so `pythonVersion` is guaranteed in `customAttributes`
+      // by the time `initializeDBTProjects()` starts — meaning a thrown
+      // error caught below is always dimensioned with at least Python
+      // version. (`dbtCoreVersion` arrives best-effort once the spawn
+      // resolves.) Re-runs on interpreter change so the dimensions track
+      // the user's selection. `detectDBT()` is the earliest point where
+      // `pythonEnvironment.executionDetails` is set and `pythonVersion`
+      // is populated.
+      void this.refreshVersionTelemetryAttributes();
+      const pythonEnv = this.dbtProjectContainer.getPythonEnvironment();
+      this.disposables.push(
+        pythonEnv.onPythonEnvironmentChanged(() => {
+          void this.refreshVersionTelemetryAttributes();
+        }),
+      );
+
       await this.dbtProjectContainer.initializeDBTProjects();
       await this.statusBars.initialize();
       // Ask to reload the window if the dbt integration changes
@@ -121,4 +157,56 @@ export class DBTPowerUserExtension implements Disposable {
       this.telemetry.sendTelemetryError("extensionActivationError", error);
     }
   }
+
+  /**
+   * Populate `pythonVersion` and `dbtCoreVersion` customAttributes on the
+   * telemetry service so every event from this point forward carries them.
+   * Best-effort: if either probe fails (interpreter missing, dbt-core not
+   * installed in this venv, probe timeout), the corresponding attribute is
+   * **cleared** rather than left at a stale value from the previous
+   * interpreter. Idempotent — wired both at activation and from the
+   * `onPythonEnvironmentChanged` listener.
+   *
+   * Sequence-guarded: rapid interpreter switches can fire two refreshes
+   * concurrently. A slower earlier probe finishing last would otherwise
+   * overwrite a faster later probe's results. We capture the
+   * `versionRefreshSeq` at entry and bail before any write if a newer
+   * refresh has bumped the counter.
+   */
+  private async refreshVersionTelemetryAttributes(): Promise<void> {
+    const seq = ++this.versionRefreshSeq;
+    try {
+      const pythonEnv = this.dbtProjectContainer.getPythonEnvironment();
+      const pythonVersion = pythonEnv.pythonVersion;
+      if (seq !== this.versionRefreshSeq) {
+        return;
+      }
+      if (pythonVersion) {
+        this.telemetry.setTelemetryCustomAttribute(
+          "pythonVersion",
+          pythonVersion,
+        );
+      } else {
+        this.telemetry.clearTelemetryCustomAttribute("pythonVersion");
+      }
+      const pythonPath = pythonEnv.pythonPath;
+      const dbtCoreVersion = pythonPath
+        ? await probeDbtCoreVersion(pythonPath)
+        : undefined;
+      if (seq !== this.versionRefreshSeq) {
+        return;
+      }
+      if (dbtCoreVersion) {
+        this.telemetry.setTelemetryCustomAttribute(
+          "dbtCoreVersion",
+          dbtCoreVersion,
+        );
+      } else {
+        this.telemetry.clearTelemetryCustomAttribute("dbtCoreVersion");
+      }
+    } catch {
+      // Telemetry-enrichment failures must never block activation or
+      // surface as an error — by design these dimensions are best-effort.
+    }
+  }
 }

src/telemetry/index.ts

@@ -16,6 +16,18 @@ export class TelemetryService implements vscode.Disposable {
     this.customAttributes[key] = value;
   }
 
+  /**
+   * Remove a previously-set custom attribute so it stops appearing on
+   * subsequent telemetry events. Use when the dimension no longer applies
+   * — e.g. the user switched Python interpreters and we couldn't probe a
+   * fresh value, so the previous interpreter's `pythonVersion` /
+   * `dbtCoreVersion` would otherwise carry over and corrupt dimensioning
+   * for events from the new interpreter.
+   */
+  clearTelemetryCustomAttribute(key: string) {
+    delete this.customAttributes[key];
+  }
+
   startTelemetryEvent(
     eventName: string,
     properties?: { [key: string]: string },