Merge pull request #199 from matthieu-crouzet/feat/set-up-telemetry

gblanc-1a · web-flow · commit 32ca98553410 · 2026-03-17T14:53:30.000+01:00
feat: set up telemetry
diff --git a/docs/README.md b/docs/README.md
@@ -11,7 +11,7 @@ Marketplace and registry for Copilot prompt bundles in VS Code.
 - **[Repository Installation](user-guide/repository-installation.md)** — Team-shared configurations via Git
 - **[Sources](user-guide/sources.md)** — Managing bundle sources
 - **[Profiles and Hubs](user-guide/profiles-and-hubs.md)** — Profile and Hub management
-- **[Configuration](user-guide/configuration.md)** — Extension settings
+- **[Configuration](user-guide/configuration.md)** — Extension settings and telemetry
 - **[Troubleshooting](user-guide/troubleshooting.md)** — Common issues
 
 ---
diff --git a/docs/user-guide/configuration.md b/docs/user-guide/configuration.md
@@ -14,6 +14,31 @@ Access: `File → Preferences → Settings → Extensions → Prompt Registry`
 | `promptregistry.updateCheck.autoUpdate` | Auto-install updates | `false` |
 | `promptregistry.updateCheck.cacheTTL` | Cache TTL (ms) | `300000` |
 
+## Telemetry
+
+Telemetry respects VS Code's built-in telemetry setting. To enable or disable it:
+
+1. Open **File → Preferences → Settings** (or `Cmd+,` / `Ctrl+,`)
+2. Search for `telemetry.telemetryLevel`
+3. Choose a level:
+
+| Level | Effect on Prompt Registry |
+|-------|--------------------------|
+| `all` | Telemetry events are collected |
+| `error` | Only error events are collected |
+| `crash` | Telemetry is disabled |
+| `off` | Telemetry is disabled |
+
+You can also set it in `settings.json`:
+
+```json
+{
+  "telemetry.telemetryLevel": "all"
+}
+```
+
+Enabling telemetry helps us understand how the extension is used so we can focus on the features that matter most.
+
 ## Export/Import Settings
 
 - **Export**: Registry Explorer toolbar → Export button
diff --git a/src/extension.ts b/src/extension.ts
@@ -42,6 +42,7 @@ import {
 import { ApmRuntimeManager } from './services/ApmRuntimeManager';
 import { OlafRuntimeManager } from './services/OlafRuntimeManager';
 import { SetupStateManager, SetupState } from './services/SetupStateManager';
+import { TelemetryService } from './services/TelemetryService';
 import { MigrationRegistry } from './services/MigrationRegistry';
 import { runSourceIdNormalizationMigration } from './migrations/sourceIdNormalizationMigration';
 
@@ -87,6 +88,9 @@ export class PromptRegistryExtension {
     private notificationManager: NotificationManager | undefined;
     private autoUpdateService: AutoUpdateService | undefined;
 
+    // Telemetry
+    private telemetryService: TelemetryService | undefined;
+
     // Repository-level installation services
     private lockfileManager: LockfileManager | undefined;
     private repositoryActivationService: RepositoryActivationService | undefined;
@@ -160,6 +164,9 @@ export class PromptRegistryExtension {
             // Initialize update notification system
             await this.initializeUpdateSystem();
 
+            // Initialize telemetry service
+            this.initializeTelemetry();
+
             // Initialize repository-level installation services
             await this.initializeRepositoryServices();
 
@@ -204,6 +211,9 @@ export class PromptRegistryExtension {
             this.disposables.forEach(disposable => disposable.dispose());
             this.disposables = [];
 
+            // Dispose telemetry event subscriptions
+            this.telemetryService?.dispose();
+
             // Dispose update scheduler
             this.updateScheduler?.dispose();
 
@@ -226,6 +236,18 @@ export class PromptRegistryExtension {
         }
     }
 
+    /**
+     * Initialize telemetry service and subscribe to bundle lifecycle events.
+     */
+    private initializeTelemetry(): void {
+        try {
+            this.telemetryService = TelemetryService.getInstance();
+            this.telemetryService.subscribeToRegistryEvents(this.registryManager);
+        } catch (error) {
+            this.logger.warn('Failed to initialize telemetry service (non-fatal)', error as Error);
+        }
+    }
+
     /**
      * Run data migrations (idempotent).
      * Migrations use MigrationRegistry (globalState) to track completion.
diff --git a/src/services/TelemetryService.ts b/src/services/TelemetryService.ts
@@ -0,0 +1,127 @@
+import * as vscode from 'vscode';
+import { Logger } from '../utils/logger';
+import { InstalledBundle, Profile, RegistrySource, SourceSyncedEvent } from '../types/registry';
+import { RegistryManager } from './RegistryManager';
+
+/**
+ * Telemetry service that tracks bundle lifecycle events using VS Code's
+ * built-in TelemetryLogger infrastructure.
+ *
+ * Uses `vscode.env.createTelemetryLogger` with a Logger-backed sender,
+ * so VS Code automatically respects the user's telemetry preferences
+ * (`telemetry.telemetryLevel`):
+ *  - `all`   → usage + error events are sent
+ *  - `error` → only error events are sent
+ *  - `crash` / `off` → nothing is sent
+ *
+ * The TelemetryLogger gates calls to the sender based on `isUsageEnabled`
+ * and `isErrorsEnabled`, so the sender itself logs unconditionally.
+ * Currently logs events locally — no data is sent to external servers.
+ */
+export class TelemetryService {
+    private static instance: TelemetryService;
+    private readonly telemetryLogger: vscode.TelemetryLogger;
+    private disposables: vscode.Disposable[] = [];
+
+    private constructor() {
+        const logger = Logger.getInstance();
+
+        const sender: vscode.TelemetrySender = {
+            sendEventData(eventName: string, data?: Record<string, any>): void {
+                logger.info(`[Telemetry] ${eventName} ${JSON.stringify(data)}`);
+            },
+            sendErrorData(error: Error, data?: Record<string, any>): void {
+                logger.error(`[Telemetry] ${error.message} ${JSON.stringify(data)}`);
+            }
+        };
+
+        this.telemetryLogger = vscode.env.createTelemetryLogger(sender);
+        this.telemetryLogger.logUsage('telemetryService.started');
+        this.disposables.push(this.telemetryLogger);
+    }
+
+    public static getInstance(): TelemetryService {
+        if (!TelemetryService.instance) {
+            TelemetryService.instance = new TelemetryService();
+        }
+        return TelemetryService.instance;
+    }
+
+    /**
+     * Reset the singleton instance (for testing only).
+     */
+    public static resetInstance(): void {
+        if (TelemetryService.instance) {
+            TelemetryService.instance.dispose();
+        }
+        TelemetryService.instance = undefined!;
+    }
+
+    /**
+     * Subscribe to RegistryManager bundle lifecycle events.
+     * Subscriptions are owned by this service and cleaned up on dispose().
+     */
+    public subscribeToRegistryEvents(registryManager: RegistryManager): void {
+        this.disposables.push(
+            // Bundle events
+            registryManager.onBundleInstalled((bundle) => this.trackBundleEvent('bundle.installed', bundle)),
+            registryManager.onBundleUninstalled((bundleId) => this.telemetryLogger.logUsage('bundle.uninstalled', { bundleId })),
+            registryManager.onBundleUpdated((bundle) => this.trackBundleEvent('bundle.updated', bundle)),
+            registryManager.onBundlesInstalled((bundles) => this.telemetryLogger.logUsage('bundles.installed', { count: bundles.length, bundleIds: bundles.map(b => b.bundleId) })),
+            registryManager.onBundlesUninstalled((bundleIds) => this.telemetryLogger.logUsage('bundles.uninstalled', { count: bundleIds.length, bundleIds })),
+            // Profile events
+            registryManager.onProfileActivated((profile) => this.trackProfileEvent('profile.activated', profile)),
+            registryManager.onProfileDeactivated((profileId) => this.telemetryLogger.logUsage('profile.deactivated', { profileId })),
+            registryManager.onProfileCreated((profile) => this.trackProfileEvent('profile.created', profile)),
+            registryManager.onProfileUpdated((profile) => this.trackProfileEvent('profile.updated', profile)),
+            registryManager.onProfileDeleted((profileId) => this.telemetryLogger.logUsage('profile.deleted', { profileId })),
+            // Source events
+            registryManager.onSourceAdded((source) => this.trackSourceEvent('source.added', source)),
+            registryManager.onSourceRemoved((sourceId) => this.telemetryLogger.logUsage('source.removed', { sourceId })),
+            registryManager.onSourceUpdated((sourceId) => this.telemetryLogger.logUsage('source.updated', { sourceId })),
+            registryManager.onSourceSynced((event) => this.trackSourceSyncedEvent('source.synced', event)),
+            // Preference events
+            registryManager.onAutoUpdatePreferenceChanged((event) => this.telemetryLogger.logUsage('autoUpdate.preferenceChanged', { bundleId: event.bundleId, enabled: event.enabled })),
+            registryManager.onRepositoryBundlesChanged(() => this.telemetryLogger.logUsage('repository.bundlesChanged')),
+        );
+    }
+
+    private trackBundleEvent(eventName: string, bundle: InstalledBundle): void {
+        this.telemetryLogger.logUsage(eventName, {
+            bundleId: bundle.bundleId,
+            version: bundle.version,
+            scope: bundle.scope,
+            sourceType: bundle.sourceType ?? 'unknown'
+        });
+    }
+
+    private trackProfileEvent(eventName: string, profile: Profile): void {
+        this.telemetryLogger.logUsage(eventName, {
+            profileId: profile.id,
+            name: profile.name
+        });
+    }
+
+    private trackSourceEvent(eventName: string, source: RegistrySource): void {
+        this.telemetryLogger.logUsage(eventName, {
+            sourceId: source.id,
+            type: source.type
+        });
+    }
+
+    private trackSourceSyncedEvent(eventName: string, event: SourceSyncedEvent): void {
+        this.telemetryLogger.logUsage(eventName, {
+            sourceId: event.sourceId,
+            bundleCount: event.bundleCount
+        });
+    }
+
+    /**
+     * Dispose the telemetry logger and all event subscriptions.
+     */
+    public dispose(): void {
+        this.telemetryLogger.logUsage('telemetryService.stopped');
+        this.disposables.forEach(d => d.dispose());
+        this.disposables = [];
+    }
+}
diff --git a/test/mocha.setup.js b/test/mocha.setup.js
@@ -245,7 +245,34 @@ const vscode = {
     sessionId: 'mock-session-id',
     remoteName: undefined,
     shell: '/bin/bash',
-    openExternal: (uri) => Promise.resolve(true)
+    isTelemetryEnabled: true,
+    openExternal: (uri) => Promise.resolve(true),
+    createTelemetryLogger: (sender, options) => {
+      let _isUsageEnabled = true;
+      return {
+        get isUsageEnabled() { return _isUsageEnabled; },
+        set isUsageEnabled(v) { _isUsageEnabled = v; },
+        get isErrorsEnabled() { return _isUsageEnabled; },
+        onDidChangeEnableStates: () => ({ dispose: () => {} }),
+        logUsage: (eventName, data) => {
+          if (_isUsageEnabled) {
+            sender.sendEventData(eventName, data);
+          }
+        },
+        logError: (eventNameOrError, data) => {
+          if (_isUsageEnabled) {
+            if (eventNameOrError instanceof Error) {
+              sender.sendErrorData(eventNameOrError, data);
+            } else {
+              sender.sendEventData(eventNameOrError, data);
+            }
+          }
+        },
+        dispose: () => {
+          if (sender.flush) { sender.flush(); }
+        }
+      };
+    }
   },
   ConfigurationTarget: {
     Global: 1,
diff --git a/test/services/TelemetryService.test.ts b/test/services/TelemetryService.test.ts
