Adds telemetry for walkthrough completion

Author: d13

docs/telemetry-events.md

@@ -1487,7 +1487,15 @@ or
 
 ```typescript
 {
-  'step': 'welcome-in-trial' | 'welcome-paid' | 'welcome-in-trial-expired' | 'get-started-community' | 'visualize-code-history' | 'accelerate-pr-reviews' | 'streamline-collaboration' | 'improve-workflows-with-integrations'
+  'step': 'welcome-in-trial' | 'welcome-paid' | 'welcome-in-trial-expired-eligible' | 'welcome-in-trial-expired' | 'get-started-community' | 'visualize-code-history' | 'accelerate-pr-reviews' | 'streamline-collaboration' | 'improve-workflows-with-integrations'
+}
+```
+
+### walkthrough/completion
+
+```typescript
+{
+  'context.key': 'gettingStarted' | 'visualizeCodeHistory' | 'prReviews' | 'streamlineCollaboration' | 'integrations'
 }
 ```
 

src/constants.telemetry.ts

@@ -8,6 +8,7 @@ import type { CustomEditorTypes, TreeViewTypes, WebviewTypes, WebviewViewTypes }
 import type { GitContributionTiers } from './git/models/contributor';
 import type { Period } from './plus/webviews/timeline/protocol';
 import type { Flatten } from './system/object';
+import type { WalkthroughContextKeys } from './telemetry/walkthroughStateProvider';
 
 export type TelemetryGlobalContext = {
 	'cloudIntegrations.connected.count': number;
@@ -397,6 +398,9 @@ export type TelemetryEvents = {
 	walkthrough: {
 		step?: WalkthroughSteps;
 	};
+	'walkthrough/completion': {
+		'context.key': WalkthroughContextKeys;
+	};
 } & Record<`${WebviewTypes | WebviewViewTypes}/showAborted`, WebviewShownEventData> &
 	Record<
 		`${Exclude<WebviewTypes | WebviewViewTypes, 'commitDetails' | 'graph' | 'graphDetails' | 'timeline'>}/shown`,

src/constants.ts

@@ -175,6 +175,7 @@ export const urls = Object.freeze({
 export type WalkthroughSteps =
 	| 'welcome-in-trial'
 	| 'welcome-paid'
+	| 'welcome-in-trial-expired-eligible'
 	| 'welcome-in-trial-expired'
 	| 'get-started-community'
 	| 'visualize-code-history'

src/telemetry/walkthroughStateProvider.ts

@@ -3,7 +3,6 @@ import { Disposable, EventEmitter } from 'vscode';
 import { Commands } from '../constants.commands';
 import type { TrackedUsageKeys } from '../constants.telemetry';
 import type { Container } from '../container';
-import { entries } from '../system/object';
 import { wait } from '../system/promise';
 import { setContext } from '../system/vscode/context';
 import type { UsageChangeEvent } from './usageTracker';
@@ -16,67 +15,108 @@ export enum WalkthroughContextKeys {
 	Integrations = 'integrations',
 }
 
+type WalkthroughUsage = { states: TrackedUsageKeys[]; usage: TrackedUsageKeys[] };
+
+const walkthroughRequiredMapping: Readonly<Map<WalkthroughContextKeys, WalkthroughUsage>> = new Map<
+	WalkthroughContextKeys,
+	WalkthroughUsage
+>([
+	[
+		WalkthroughContextKeys.GettingStarted,
+		{
+			states: [
+				`command:${Commands.PlusStartPreviewTrial}:executed`,
+				`command:${Commands.PlusReactivateProTrial}:executed`,
+				`command:${Commands.OpenWalkthrough}:executed`,
+				`command:${Commands.GetStarted}:executed`,
+			],
+			usage: [],
+		},
+	],
+	[
+		WalkthroughContextKeys.VisualizeCodeHistory,
+		{
+			states: [
+				`command:${Commands.PlusStartPreviewTrial}:executed`,
+				`command:${Commands.PlusReactivateProTrial}:executed`,
+			],
+			usage: [
+				'graphDetailsView:shown',
+				'graphView:shown',
+				'graphWebview:shown',
+				'commitDetailsView:shown',
+				`command:${Commands.ShowGraph}:executed`,
+				`command:${Commands.ShowGraphPage}:executed`,
+				`command:${Commands.ShowGraphView}:executed`,
+				`command:${Commands.ShowInCommitGraph}:executed`,
+				`command:${Commands.ShowInCommitGraphView}:executed`,
+			],
+		},
+	],
+	[
+		WalkthroughContextKeys.PrReviews,
+		{
+			states: [
+				`command:${Commands.PlusStartPreviewTrial}:executed`,
+				`command:${Commands.PlusReactivateProTrial}:executed`,
+			],
+			usage: [
+				'launchpadView:shown',
+				'worktreesView:shown',
+				`command:${Commands.ShowLaunchpad}:executed`,
+				`command:${Commands.ShowLaunchpadView}:executed`,
+				`command:${Commands.GitCommandsWorktree}:executed`,
+				`command:${Commands.GitCommandsWorktreeCreate}:executed`,
+				`command:${Commands.GitCommandsWorktreeDelete}:executed`,
+				`command:${Commands.GitCommandsWorktreeOpen}:executed`,
+			],
+		},
+	],
+	[
+		WalkthroughContextKeys.StreamlineCollaboration,
+		{
+			states: [
+				`command:${Commands.PlusStartPreviewTrial}:executed`,
+				`command:${Commands.PlusReactivateProTrial}:executed`,
+			],
+			usage: [`command:${Commands.CreateCloudPatch}:executed`, `command:${Commands.CreatePatch}:executed`],
+		},
+	],
+	[
+		WalkthroughContextKeys.Integrations,
+		{
+			states: [],
+			usage: [
+				`command:${Commands.PlusConnectCloudIntegrations}:executed`,
+				`command:${Commands.PlusManageCloudIntegrations}:executed`,
+			],
+		},
+	],
+]);
+
 export class WalkthroughStateProvider implements Disposable {
 	protected disposables: Disposable[] = [];
-	private readonly state = new Map<WalkthroughContextKeys, boolean>();
+	private readonly completed = new Set<WalkthroughContextKeys>();
 	readonly walkthroughSize: number;
-	private isInitialized = false;
-	private _initPromise: Promise<void> | undefined;
 
-	/**
-	 * using reversed map (instead of direct map as walkthroughToTracking Record<WalkthroughContextKeys, TrackedUsageKeys[]>)
-	 * makes code less readable, but prevents duplicated usageTracker keys
-	 */
-	private readonly walkthroughByTracking: Partial<Record<TrackedUsageKeys, WalkthroughContextKeys>> = {
-		[`command:${Commands.PlusStartPreviewTrial}:executed`]: WalkthroughContextKeys.GettingStarted,
-		[`command:${Commands.PlusReactivateProTrial}:executed`]: WalkthroughContextKeys.GettingStarted,
-		[`command:${Commands.ShowWelcomePage}:executed`]: WalkthroughContextKeys.GettingStarted,
-		[`command:${Commands.OpenWalkthrough}:executed`]: WalkthroughContextKeys.GettingStarted,
-		[`command:${Commands.GetStarted}:executed`]: WalkthroughContextKeys.GettingStarted,
-
-		'graphDetailsView:shown': WalkthroughContextKeys.VisualizeCodeHistory,
-		'graphView:shown': WalkthroughContextKeys.VisualizeCodeHistory,
-		'graphWebview:shown': WalkthroughContextKeys.VisualizeCodeHistory,
-		'commitDetailsView:shown': WalkthroughContextKeys.VisualizeCodeHistory,
-		[`command:${Commands.ShowGraph}:executed`]: WalkthroughContextKeys.VisualizeCodeHistory,
-		[`command:${Commands.ShowGraphPage}:executed`]: WalkthroughContextKeys.VisualizeCodeHistory,
-		[`command:${Commands.ShowGraphView}:executed`]: WalkthroughContextKeys.VisualizeCodeHistory,
-		[`command:${Commands.ShowInCommitGraph}:executed`]: WalkthroughContextKeys.VisualizeCodeHistory,
-		[`command:${Commands.ShowInCommitGraphView}:executed`]: WalkthroughContextKeys.VisualizeCodeHistory,
-
-		'launchpadView:shown': WalkthroughContextKeys.PrReviews,
-		'worktreesView:shown': WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.ShowLaunchpad}:executed`]: WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.ShowLaunchpadView}:executed`]: WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.GitCommandsWorktree}:executed`]: WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.GitCommandsWorktreeCreate}:executed`]: WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.GitCommandsWorktreeDelete}:executed`]: WalkthroughContextKeys.PrReviews,
-		[`command:${Commands.GitCommandsWorktreeOpen}:executed`]: WalkthroughContextKeys.PrReviews,
-
-		[`command:${Commands.CreateCloudPatch}:executed`]: WalkthroughContextKeys.StreamlineCollaboration,
-		[`command:${Commands.CreatePatch}:executed`]: WalkthroughContextKeys.StreamlineCollaboration,
-
-		[`command:${Commands.PlusConnectCloudIntegrations}:executed`]: WalkthroughContextKeys.Integrations,
-		[`command:${Commands.PlusManageCloudIntegrations}:executed`]: WalkthroughContextKeys.Integrations,
-	};
 	private readonly _onProgressChanged = new EventEmitter<void>();
+	get onProgressChanged(): Event<void> {
+		return this._onProgressChanged.event;
+	}
 
 	constructor(private readonly container: Container) {
 		this.disposables.push(this.container.usage.onDidChange(this.onUsageChanged, this));
-		this.walkthroughSize = Object.values(WalkthroughContextKeys).length;
+		this.walkthroughSize = walkthroughRequiredMapping.size;
 
 		this.initializeState();
 	}
 
 	private initializeState() {
-		for (const key of Object.values(WalkthroughContextKeys)) {
-			this.state.set(key, false);
-		}
-		entries(this.walkthroughByTracking).forEach(([usageKey, walkthroughKey]) => {
-			if (!this.state.get(walkthroughKey) && this.container.usage.isUsed(usageKey)) {
-				void this.completeStep(walkthroughKey);
+		for (const key of walkthroughRequiredMapping.keys()) {
+			if (this.validateStep(key)) {
+				void this.completeStep(key);
 			}
-		});
+		}
 		this._onProgressChanged.fire(undefined);
 	}
 
@@ -85,25 +125,42 @@ export class WalkthroughStateProvider implements Disposable {
 		if (!usageTrackingKey) {
 			return;
 		}
-		const walkthroughKey = this.walkthroughByTracking[usageTrackingKey];
-		if (walkthroughKey) {
-			void this.completeStep(walkthroughKey);
+
+		const stepsToValidate = this.getStepsFromUsage(usageTrackingKey);
+		let shouldFire = false;
+		for (const step of stepsToValidate) {
+			// no need to check if the step is already completed
+			if (this.completed.has(step)) {
+				continue;
+			}
+
+			if (this.validateStep(step)) {
+				void this.completeStep(step);
+				this.container.telemetry.sendEvent('walkthrough/completion', {
+					'context.key': step,
+				});
+				shouldFire = true;
+			}
+		}
+		if (shouldFire) {
 			this._onProgressChanged.fire(undefined);
 		}
 	}
 
+	private _isInitialized: boolean = false;
+	private _initPromise: Promise<void> | undefined;
 	/**
 	 * Walkthrough view is not ready to listen to context changes immediately after opening VSCode with the walkthrough page opened
 	 * As we're not able to check if the walkthrough is ready, we need to add a delay.
 	 * The 1s delay will not be too annoying for user but it's enough to init
 	 */
 	private async waitForWalkthroughInitialized() {
-		if (this.isInitialized) {
+		if (this._isInitialized) {
 			return;
 		}
 		if (!this._initPromise) {
 			this._initPromise = wait(1000).then(() => {
-				this.isInitialized = true;
+				this._isInitialized = true;
 			});
 		}
 		await this._initPromise;
@@ -115,17 +172,13 @@ export class WalkthroughStateProvider implements Disposable {
 	 * we don't have an ability to reset the flag
 	 */
 	private async completeStep(key: WalkthroughContextKeys) {
-		this.state.set(key, true);
+		this.completed.add(key);
 		await this.waitForWalkthroughInitialized();
 		void setContext(`gitlens:walkthroughState:${key}`, true);
 	}
 
-	get onProgressChanged(): Event<void> {
-		return this._onProgressChanged.event;
-	}
-
 	get doneCount() {
-		return [...this.state.values()].filter(x => x).length;
+		return this.completed.size;
 	}
 
 	get progress() {
@@ -135,4 +188,26 @@ export class WalkthroughStateProvider implements Disposable {
 	dispose(): void {
 		Disposable.from(...this.disposables).dispose();
 	}
+
+	private getStepsFromUsage(usageKey: TrackedUsageKeys): WalkthroughContextKeys[] {
+		const keys: WalkthroughContextKeys[] = [];
+		for (const [key, { states, usage: events }] of walkthroughRequiredMapping) {
+			if (states.includes(usageKey) || events.includes(usageKey)) {
+				keys.push(key);
+			}
+		}
+
+		return keys;
+	}
+
+	private validateStep(key: WalkthroughContextKeys): boolean {
+		const { states, usage: events } = walkthroughRequiredMapping.get(key)!;
+		if (states.length && !states.some(state => this.container.usage.isUsed(state))) {
+			return false;
+		}
+		if (events.length && !events.some(event => this.container.usage.isUsed(event))) {
+			return false;
+		}
+		return true;
+	}
 }