Merge pull request #1438 from RooVetGit/telemetry

Opt-in telemetry

.env.sample

@@ -0,0 +1,2 @@
+# PostHog API Keys for telemetry
+POSTHOG_API_KEY=key-goes-here

.github/workflows/marketplace-publish.yml

@@ -30,6 +30,10 @@ jobs:
         run: |
           npm install -g vsce ovsx
           npm run install:ci
+      - name: Create .env file
+        run: |
+          echo "# PostHog API Keys for telemetry" > .env
+          echo "POSTHOG_API_KEY=${{ secrets.POSTHOG_API_KEY }}" >> .env
       - name: Package and Publish Extension
         env:
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
@@ -43,6 +47,7 @@ jobs:
           echo "$package" | grep -q "dist/extension.js" || exit 1
           echo "$package" | grep -q "extension/webview-ui/build/assets/index.js" || exit 1
           echo "$package" | grep -q "extension/node_modules/@vscode/codicons/dist/codicon.ttf" || exit 1
+          echo "$package" | grep -q ".env" || exit 1
 
           npm run publish:marketplace
           echo "Successfully published version $current_package_version to VS Code Marketplace"

.gitignore

@@ -21,6 +21,7 @@ roo-cline-*.vsix
 docs/_site/
 
 # Dotenv
+.env
 .env.integration
 
 #Local lint config

.rooignore

@@ -0,0 +1 @@
+.env

.vscodeignore

@@ -48,3 +48,6 @@ webview-ui/node_modules/**
 
 # Include icons
 !assets/icons/**
+
+# Include .env file for telemetry
+!.env

PRIVACY.md

@@ -0,0 +1,37 @@
+# Roo Code Privacy Policy
+
+**Last Updated: March 7th, 2025**
+
+Roo Code respects your privacy and is committed to transparency about how we handle your data. Below is a simple breakdown of where key pieces of data go—and, importantly, where they don’t.
+
+### **Where Your Data Goes (And Where It Doesn’t)**
+
+- **Code & Files**: Roo Code accesses files on your local machine when needed for AI-assisted features. When you send commands to Roo Code, relevant files may be transmitted to your chosen AI model provider (e.g., OpenAI, Anthropic, OpenRouter) to generate responses. We do not have access to this data, but AI providers may store it per their privacy policies.
+- **Commands**: Any commands executed through Roo Code happen on your local environment. However, when you use AI-powered features, the relevant code and context from your commands may be transmitted to your chosen AI model provider (e.g., OpenAI, Anthropic, OpenRouter) to generate responses. We do not have access to or store this data, but AI providers may process it per their privacy policies.
+- **Prompts & AI Requests**: When you use AI-powered features, your prompts and relevant project context are sent to your chosen AI model provider (e.g., OpenAI, Anthropic, OpenRouter) to generate responses. We do not store or process this data. These AI providers have their own privacy policies and may store data per their terms of service.
+- **API Keys & Credentials**: If you enter an API key (e.g., to connect an AI model), it is stored locally on your device and never sent to us or any third party, except the provider you have chosen.
+- **Telemetry (Usage Data)**: We only collect feature usage and error data if you explicitly opt-in. This telemetry is powered by PostHog and helps us understand feature usage to improve Roo Code. This includes your VS Code machine ID and feature usage patterns and exception reports. We do **not** collect personally identifiable information, your code, or AI prompts.
+
+### **How We Use Your Data (If Collected)**
+
+- If you opt-in to telemetry, we use it to understand feature usage and improve Roo Code.
+- We do **not** sell or share your data.
+- We do **not** train any models on your data.
+
+### **Your Choices & Control**
+
+- You can run models locally to prevent data being sent to third-parties.
+- By default, telemetry collection is off and if you turn it on, you can opt out of telemetry at any time.
+- You can delete Roo Code to stop all data collection.
+
+### **Security & Updates**
+
+We take reasonable measures to secure your data, but no system is 100% secure. If our privacy policy changes, we will notify you within the extension.
+
+### **Contact Us**
+
+For any privacy-related questions, reach out to us at [email protected].
+
+---
+
+By using Roo Code, you agree to this Privacy Policy.

package-lock.json

@@ -42,6 +42,7 @@
 				"os-name": "^6.0.0",
 				"p-wait-for": "^5.0.2",
 				"pdf-parse": "^1.1.1",
+				"posthog-node": "^4.7.0",
 				"pretty-bytes": "^6.1.1",
 				"puppeteer-chromium-resolver": "^23.0.0",
 				"puppeteer-core": "^23.4.0",
@@ -12877,6 +12878,17 @@
 				"node": ">= 0.4"
 			}
 		},
+		"node_modules/posthog-node": {
+			"version": "4.7.0",
+			"resolved": "https://registry.npmjs.org/posthog-node/-/posthog-node-4.7.0.tgz",
+			"integrity": "sha512-RgdUKSW8MfMOkjUa8cYVqWndNjPePNuuxlGbrZC6z1WRBsVc6TdGl8caidmC10RW8mu/BOfmrGbP4cRTo2jARg==",
+			"dependencies": {
+				"axios": "^1.7.4"
+			},
+			"engines": {
+				"node": ">=15.0.0"
+			}
+		},
 		"node_modules/prelude-ls": {
 			"version": "1.2.1",
 			"resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",

package.json

@@ -295,6 +295,7 @@
 		"os-name": "^6.0.0",
 		"p-wait-for": "^5.0.2",
 		"pdf-parse": "^1.1.1",
+		"posthog-node": "^4.7.0",
 		"pretty-bytes": "^6.1.1",
 		"puppeteer-chromium-resolver": "^23.0.0",
 		"puppeteer-core": "^23.4.0",

src/core/Cline.ts

@@ -71,6 +71,7 @@ import { McpHub } from "../services/mcp/McpHub"
 import crypto from "crypto"
 import { insertGroups } from "./diff/insert-groups"
 import { OutputBuilder } from "../integrations/terminal/OutputBuilder"
+import { telemetryService } from "../services/telemetry/TelemetryService"
 
 const cwd =
 	vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop") // may or may not exist but fs checking existence would immediately ask for permission which would be bad UX, need to come up with a better solution
@@ -190,6 +191,12 @@ export class Cline {
 		this.enableCheckpoints = enableCheckpoints
 		this.checkpointStorage = checkpointStorage
 
+		if (historyItem) {
+			telemetryService.captureTaskRestarted(this.taskId)
+		} else {
+			telemetryService.captureTaskCreated(this.taskId)
+		}
+
 		// Initialize diffStrategy based on current state
 		this.updateDiffStrategy(
 			Experiments.isEnabled(experiments ?? {}, EXPERIMENT_IDS.DIFF_STRATEGY),
@@ -1446,6 +1453,10 @@ export class Cline {
 					await this.browserSession.closeBrowser()
 				}
 
+				if (!block.partial) {
+					telemetryService.captureToolUsage(this.taskId, block.name)
+				}
+
 				// Validate tool use before execution
 				const { mode, customModes } = (await this.providerRef.deref()?.getState()) ?? {}
 				try {
@@ -2897,14 +2908,6 @@ export class Cline {
 											false,
 										)
 
-										if (this.isSubTask) {
-											// tell the provider to remove the current subtask and resume the previous task in the stack (it might decide to run the command)
-											await this.providerRef
-												.deref()
-												?.finishSubTask(`new_task finished successfully! ${lastMessage?.text}`)
-											break
-										}
-
 										await this.ask(
 											"command",
 											removeClosingTag("command", command),
@@ -2936,6 +2939,7 @@ export class Cline {
 									if (lastMessage && lastMessage.ask !== "command") {
 										// havent sent a command message yet so first send completion_result then command
 										await this.say("completion_result", result, undefined, false)
+										telemetryService.captureTaskCompleted(this.taskId)
 										if (this.isSubTask) {
 											// tell the provider to remove the current subtask and resume the previous task in the stack
 											await this.providerRef
@@ -2960,6 +2964,7 @@ export class Cline {
 									commandResult = execCommandResult
 								} else {
 									await this.say("completion_result", result, undefined, false)
+									telemetryService.captureTaskCompleted(this.taskId)
 									if (this.isSubTask) {
 										// tell the provider to remove the current subtask and resume the previous task in the stack
 										await this.providerRef
@@ -3125,6 +3130,7 @@ export class Cline {
 		userContent.push({ type: "text", text: environmentDetails })
 
 		await this.addToApiConversationHistory({ role: "user", content: userContent })
+		telemetryService.captureConversationMessage(this.taskId, "user")
 
 		// since we sent off a placeholder api_req_started message to update the webview while waiting to actually start the API request (to load potential details for example), we need to update the text of that message
 		const lastApiReqIndex = findLastIndex(this.clineMessages, (m) => m.say === "api_req_started")
@@ -3326,6 +3332,7 @@ export class Cline {
 					role: "assistant",
 					content: [{ type: "text", text: assistantMessage }],
 				})
+				telemetryService.captureConversationMessage(this.taskId, "assistant")
 
 				// NOTE: this comment is here for future reference - this was a workaround for userMessageContent not getting set to true. It was due to it not recursively calling for partial blocks when didRejectTool, so it would get stuck waiting for a partial block to complete before it could continue.
 				// in case the content blocks finished

src/core/webview/ClineProvider.ts

@@ -53,6 +53,8 @@ import { Cline, ClineOptions } from "../Cline"
 import { openMention } from "../mentions"
 import { getNonce } from "./getNonce"
 import { getUri } from "./getUri"
+import { telemetryService } from "../../services/telemetry/TelemetryService"
+import { TelemetrySetting } from "../../shared/TelemetrySetting"
 
 /**
  * https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -82,6 +84,10 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		this.outputChannel.appendLine("ClineProvider instantiated")
 		this.contextProxy = new ContextProxy(context)
 		ClineProvider.activeInstances.add(this)
+
+		// Register this provider with the telemetry service to enable it to add properties like mode and provider
+		telemetryService.setProvider(this)
+
 		this.workspaceTracker = new WorkspaceTracker(this)
 		this.configManager = new ConfigManager(this.context)
 		this.customModesManager = new CustomModesManager(this.context, async () => {
@@ -620,8 +626,8 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			`font-src ${webview.cspSource}`,
 			`style-src ${webview.cspSource} 'unsafe-inline' https://* http://${localServerUrl} http://0.0.0.0:${localPort}`,
 			`img-src ${webview.cspSource} data:`,
-			`script-src 'unsafe-eval' https://* http://${localServerUrl} http://0.0.0.0:${localPort} 'nonce-${nonce}'`,
-			`connect-src https://* ws://${localServerUrl} ws://0.0.0.0:${localPort} http://${localServerUrl} http://0.0.0.0:${localPort}`,
+			`script-src 'unsafe-eval' https://* https://*.posthog.com http://${localServerUrl} http://0.0.0.0:${localPort} 'nonce-${nonce}'`,
+			`connect-src https://* https://*.posthog.com ws://${localServerUrl} ws://0.0.0.0:${localPort} http://${localServerUrl} http://0.0.0.0:${localPort}`,
 		]
 
 		return /*html*/ `
@@ -710,7 +716,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
             <meta charset="utf-8">
             <meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
             <meta name="theme-color" content="#000000">
-            <meta http-equiv="Content-Security-Policy" content="default-src 'none'; font-src ${webview.cspSource}; style-src ${webview.cspSource} 'unsafe-inline'; img-src ${webview.cspSource} data:; script-src 'nonce-${nonce}';">
+            <meta http-equiv="Content-Security-Policy" content="default-src 'none'; font-src ${webview.cspSource}; style-src ${webview.cspSource} 'unsafe-inline'; img-src ${webview.cspSource} data:; script-src 'nonce-${nonce}' https://us-assets.i.posthog.com; connect-src https://us.i.posthog.com https://us-assets.i.posthog.com;">
             <link rel="stylesheet" type="text/css" href="${stylesUri}">
 			<link href="${codiconsUri}" rel="stylesheet" />
             <title>Roo Code</title>
@@ -925,6 +931,13 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 								),
 							)
 
+						// If user already opted in to telemetry, enable telemetry service
+						this.getStateToPostToWebview().then((state) => {
+							const { telemetrySetting } = state
+							const isOptedIn = telemetrySetting === "enabled"
+							telemetryService.updateTelemetryState(isOptedIn)
+						})
+
 						this.isViewLaunched = true
 						break
 					case "newTask":
@@ -1776,6 +1789,15 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 							})
 						}
 						break
+
+					case "telemetrySetting": {
+						const telemetrySetting = message.text as TelemetrySetting
+						await this.updateGlobalState("telemetrySetting", telemetrySetting)
+						const isOptedIn = telemetrySetting === "enabled"
+						telemetryService.updateTelemetryState(isOptedIn)
+						await this.postStateToWebview()
+						break
+					}
 				}
 			},
 			null,
@@ -1835,6 +1857,12 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	 * @param newMode The mode to switch to
 	 */
 	public async handleModeSwitch(newMode: Mode) {
+		// Capture mode switch telemetry event
+		const currentTaskId = this.getCurrentCline()?.taskId
+		if (currentTaskId) {
+			telemetryService.captureModeSwitch(currentTaskId, newMode)
+		}
+
 		await this.updateGlobalState("mode", newMode)
 
 		// Load the saved API config for the new mode if it exists
@@ -2172,7 +2200,10 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			experiments,
 			maxOpenTabsContext,
 			browserToolEnabled,
+			telemetrySetting,
 		} = await this.getState()
+		const telemetryKey = process.env.POSTHOG_API_KEY
+		const machineId = vscode.env.machineId
 
 		const allowedCommands = vscode.workspace.getConfiguration("roo-cline").get<string[]>("allowedCommands") || []
 
@@ -2200,7 +2231,8 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			diffEnabled: diffEnabled ?? true,
 			enableCheckpoints: enableCheckpoints ?? true,
 			checkpointStorage: checkpointStorage ?? "task",
-			shouldShowAnnouncement: lastShownAnnouncementId !== this.latestAnnouncementId,
+			shouldShowAnnouncement:
+				telemetrySetting !== "unset" && lastShownAnnouncementId !== this.latestAnnouncementId,
 			allowedCommands,
 			soundVolume: soundVolume ?? 0.5,
 			browserViewportSize: browserViewportSize ?? "900x600",
@@ -2225,8 +2257,11 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			experiments: experiments ?? experimentDefault,
 			mcpServers: this.mcpHub?.getAllServers() ?? [],
 			maxOpenTabsContext: maxOpenTabsContext ?? 20,
-			cwd: cwd,
+			cwd,
 			browserToolEnabled: browserToolEnabled ?? true,
+			telemetrySetting,
+			telemetryKey,
+			machineId,
 		}
 	}
 
@@ -2405,6 +2440,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			maxOpenTabsContext: stateValues.maxOpenTabsContext ?? 20,
 			openRouterUseMiddleOutTransform: stateValues.openRouterUseMiddleOutTransform ?? true,
 			browserToolEnabled: stateValues.browserToolEnabled ?? true,
+			telemetrySetting: stateValues.telemetrySetting || "unset",
 		}
 	}
 
@@ -2483,4 +2519,27 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	public getMcpHub(): McpHub | undefined {
 		return this.mcpHub
 	}
+
+	/**
+	 * Returns properties to be included in every telemetry event
+	 * This method is called by the telemetry service to get context information
+	 * like the current mode, API provider, etc.
+	 */
+	public async getTelemetryProperties(): Promise<Record<string, any>> {
+		const { mode, apiConfiguration } = await this.getState()
+
+		const properties: Record<string, any> = {}
+
+		// Add current mode
+		if (mode) {
+			properties.mode = mode
+		}
+
+		// Add API provider
+		if (apiConfiguration?.apiProvider) {
+			properties.apiProvider = apiConfiguration.apiProvider
+		}
+
+		return properties
+	}
 }

src/core/webview/__tests__/ClineProvider.test.ts

@@ -401,6 +401,12 @@ describe("ClineProvider", () => {
 		})
 
 		expect(mockWebviewView.webview.html).toContain("<!DOCTYPE html>")
+
+		// Verify Content Security Policy contains the necessary PostHog domains
+		expect(mockWebviewView.webview.html).toContain("connect-src https://us.i.posthog.com")
+		expect(mockWebviewView.webview.html).toContain("https://us-assets.i.posthog.com")
+		expect(mockWebviewView.webview.html).toContain("script-src 'nonce-")
+		expect(mockWebviewView.webview.html).toContain("https://us-assets.i.posthog.com")
 	})
 
 	test("postMessageToWebview sends message to webview", async () => {
@@ -438,6 +444,7 @@ describe("ClineProvider", () => {
 			experiments: experimentDefault,
 			maxOpenTabsContext: 20,
 			browserToolEnabled: true,
+			telemetrySetting: "unset",
 		}
 
 		const message: ExtensionMessage = {

src/extension.ts

@@ -1,4 +1,15 @@
 import * as vscode from "vscode"
+import * as dotenvx from "@dotenvx/dotenvx"
+
+// Load environment variables from .env file
+try {
+	// Specify path to .env file in the project root directory
+	const envPath = __dirname + "/../.env"
+	dotenvx.config({ path: envPath })
+} catch (e) {
+	// Silently handle environment loading errors
+	console.warn("Failed to load environment variables:", e)
+}
 
 import { ClineProvider } from "./core/webview/ClineProvider"
 import { createClineAPI } from "./exports"
@@ -7,6 +18,7 @@ import { CodeActionProvider } from "./core/CodeActionProvider"
 import { DIFF_VIEW_URI_SCHEME } from "./integrations/editor/DiffViewProvider"
 import { handleUri, registerCommands, registerCodeActions } from "./activate"
 import { McpServerManager } from "./services/mcp/McpServerManager"
+import { telemetryService } from "./services/telemetry/TelemetryService"
 
 /**
  * Built using https://github.com/microsoft/vscode-webview-ui-toolkit
@@ -39,6 +51,9 @@ export function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(outputChannel)
 	outputChannel.appendLine("Roo-Code extension activated")
 
+	// Initialize telemetry service after environment variables are loaded
+	telemetryService.initialize()
+
 	// Get default commands from configuration.
 	const defaultCommands = vscode.workspace.getConfiguration("roo-cline").get<string[]>("allowedCommands") || []
 
@@ -46,8 +61,8 @@ export function activate(context: vscode.ExtensionContext) {
 	if (!context.globalState.get("allowedCommands")) {
 		context.globalState.update("allowedCommands", defaultCommands)
 	}
-
 	const sidebarProvider = new ClineProvider(context, outputChannel)
+	telemetryService.setProvider(sidebarProvider)
 
 	context.subscriptions.push(
 		vscode.window.registerWebviewViewProvider(ClineProvider.sideBarId, sidebarProvider, {
@@ -136,4 +151,5 @@ export async function deactivate() {
 	outputChannel.appendLine("Roo-Code extension deactivated")
 	// Clean up MCP server manager
 	await McpServerManager.cleanup(extensionContext)
+	telemetryService.shutdown()
 }

src/services/telemetry/TelemetryService.ts

@@ -0,0 +1,268 @@
+import { PostHog } from "posthog-node"
+import * as vscode from "vscode"
+import { logger } from "../../utils/logging"
+
+// This forward declaration is needed to avoid circular dependencies
+interface ClineProviderInterface {
+	// Gets telemetry properties to attach to every event
+	getTelemetryProperties(): Promise<Record<string, any>>
+}
+
+/**
+ * PostHogClient handles telemetry event tracking for the Roo Code extension
+ * Uses PostHog analytics to track user interactions and system events
+ * Respects user privacy settings and VSCode's global telemetry configuration
+ */
+class PostHogClient {
+	public static readonly EVENTS = {
+		TASK: {
+			CREATED: "Task Created",
+			RESTARTED: "Task Reopened",
+			COMPLETED: "Task Completed",
+			CONVERSATION_MESSAGE: "Conversation Message",
+			MODE_SWITCH: "Mode Switched",
+			TOOL_USED: "Tool Used",
+		},
+	}
+
+	private static instance: PostHogClient
+	private client: PostHog
+	private distinctId: string = vscode.env.machineId
+	private telemetryEnabled: boolean = false
+	private providerRef: WeakRef<ClineProviderInterface> | null = null
+
+	private constructor() {
+		this.client = new PostHog(process.env.POSTHOG_API_KEY || "", {
+			host: "https://us.i.posthog.com",
+		})
+	}
+
+	/**
+	 * Updates the telemetry state based on user preferences and VSCode settings
+	 * Only enables telemetry if both VSCode global telemetry is enabled and user has opted in
+	 * @param didUserOptIn Whether the user has explicitly opted into telemetry
+	 */
+	public updateTelemetryState(didUserOptIn: boolean): void {
+		this.telemetryEnabled = false
+
+		// First check global telemetry level - telemetry should only be enabled when level is "all"
+		const telemetryLevel = vscode.workspace.getConfiguration("telemetry").get<string>("telemetryLevel", "all")
+		const globalTelemetryEnabled = telemetryLevel === "all"
+
+		// We only enable telemetry if global vscode telemetry is enabled
+		if (globalTelemetryEnabled) {
+			this.telemetryEnabled = didUserOptIn
+		}
+
+		// Update PostHog client state based on telemetry preference
+		if (this.telemetryEnabled) {
+			this.client.optIn()
+		} else {
+			this.client.optOut()
+		}
+	}
+
+	/**
+	 * Gets or creates the singleton instance of PostHogClient
+	 * @returns The PostHogClient instance
+	 */
+	public static getInstance(): PostHogClient {
+		if (!PostHogClient.instance) {
+			PostHogClient.instance = new PostHogClient()
+		}
+		return PostHogClient.instance
+	}
+
+	/**
+	 * Sets the ClineProvider reference to use for global properties
+	 * @param provider A ClineProvider instance to use
+	 */
+	public setProvider(provider: ClineProviderInterface): void {
+		this.providerRef = new WeakRef(provider)
+		logger.debug("PostHogClient: ClineProvider reference set")
+	}
+
+	/**
+	 * Captures a telemetry event if telemetry is enabled
+	 * @param event The event to capture with its properties
+	 */
+	public async capture(event: { event: string; properties?: any }): Promise<void> {
+		// Only send events if telemetry is enabled
+		if (this.telemetryEnabled) {
+			// Get global properties from ClineProvider if available
+			let globalProperties: Record<string, any> = {}
+			const provider = this.providerRef?.deref()
+
+			if (provider) {
+				try {
+					// Get the telemetry properties directly from the provider
+					globalProperties = await provider.getTelemetryProperties()
+				} catch (error) {
+					// Log error but continue with capturing the event
+					logger.error(
+						`Error getting telemetry properties: ${error instanceof Error ? error.message : String(error)}`,
+					)
+				}
+			}
+
+			// Merge global properties with event-specific properties
+			// Event properties take precedence in case of conflicts
+			const mergedProperties = {
+				...globalProperties,
+				...(event.properties || {}),
+			}
+
+			this.client.capture({
+				distinctId: this.distinctId,
+				event: event.event,
+				properties: mergedProperties,
+			})
+		}
+	}
+
+	/**
+	 * Checks if telemetry is currently enabled
+	 * @returns Whether telemetry is enabled
+	 */
+	public isTelemetryEnabled(): boolean {
+		return this.telemetryEnabled
+	}
+
+	/**
+	 * Shuts down the PostHog client
+	 */
+	public async shutdown(): Promise<void> {
+		await this.client.shutdown()
+	}
+}
+
+/**
+ * TelemetryService wrapper class that defers PostHogClient initialization
+ * This ensures that we only create the PostHogClient after environment variables are loaded
+ */
+class TelemetryService {
+	private client: PostHogClient | null = null
+	private initialized = false
+	private providerRef: WeakRef<ClineProviderInterface> | null = null
+
+	/**
+	 * Initialize the telemetry service with the PostHog client
+	 * This should be called after environment variables are loaded
+	 */
+	public initialize(): void {
+		if (this.initialized) {
+			return
+		}
+
+		try {
+			this.client = PostHogClient.getInstance()
+			this.initialized = true
+		} catch (error) {
+			console.warn("Failed to initialize telemetry service:", error)
+		}
+	}
+
+	/**
+	 * Sets the ClineProvider reference to use for global properties
+	 * @param provider A ClineProvider instance to use
+	 */
+	public setProvider(provider: ClineProviderInterface): void {
+		// Keep a weak reference to avoid memory leaks
+		this.providerRef = new WeakRef(provider)
+		// If client is initialized, pass the provider reference
+		if (this.isReady()) {
+			this.client!.setProvider(provider)
+		}
+		logger.debug("TelemetryService: ClineProvider reference set")
+	}
+
+	/**
+	 * Base method for all telemetry operations
+	 * Checks if the service is initialized before performing any operation
+	 * @returns Whether the service is ready to use
+	 */
+	private isReady(): boolean {
+		return this.initialized && this.client !== null
+	}
+
+	/**
+	 * Updates the telemetry state based on user preferences and VSCode settings
+	 * @param didUserOptIn Whether the user has explicitly opted into telemetry
+	 */
+	public updateTelemetryState(didUserOptIn: boolean): void {
+		if (!this.isReady()) return
+		this.client!.updateTelemetryState(didUserOptIn)
+	}
+
+	/**
+	 * Captures a telemetry event if telemetry is enabled
+	 * @param event The event to capture with its properties
+	 */
+	public capture(event: { event: string; properties?: any }): void {
+		if (!this.isReady()) return
+		this.client!.capture(event)
+	}
+
+	/**
+	 * Generic method to capture any type of event with specified properties
+	 * @param eventName The event name to capture
+	 * @param properties The event properties
+	 */
+	public captureEvent(eventName: string, properties?: any): void {
+		this.capture({ event: eventName, properties })
+	}
+
+	// Task events convenience methods
+	public captureTaskCreated(taskId: string): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.CREATED, { taskId })
+	}
+
+	public captureTaskRestarted(taskId: string): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.RESTARTED, { taskId })
+	}
+
+	public captureTaskCompleted(taskId: string): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.COMPLETED, { taskId })
+	}
+
+	public captureConversationMessage(taskId: string, source: "user" | "assistant"): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.CONVERSATION_MESSAGE, {
+			taskId,
+			source,
+		})
+	}
+
+	public captureModeSwitch(taskId: string, newMode: string): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.MODE_SWITCH, {
+			taskId,
+			newMode,
+		})
+	}
+
+	public captureToolUsage(taskId: string, tool: string): void {
+		this.captureEvent(PostHogClient.EVENTS.TASK.TOOL_USED, {
+			taskId,
+			tool,
+		})
+	}
+
+	/**
+	 * Checks if telemetry is currently enabled
+	 * @returns Whether telemetry is enabled
+	 */
+	public isTelemetryEnabled(): boolean {
+		if (!this.isReady()) return false
+		return this.client!.isTelemetryEnabled()
+	}
+
+	/**
+	 * Shuts down the PostHog client
+	 */
+	public async shutdown(): Promise<void> {
+		if (!this.isReady()) return
+		await this.client!.shutdown()
+	}
+}
+
+// Export a singleton instance of the telemetry service wrapper
+export const telemetryService = new TelemetryService()

src/shared/ExtensionMessage.ts

@@ -8,6 +8,7 @@ import { Mode, CustomModePrompts, ModeConfig } from "./modes"
 import { CustomSupportPrompts } from "./support-prompt"
 import { ExperimentId } from "./experiments"
 import { CheckpointStorage } from "./checkpoints"
+import { TelemetrySetting } from "./TelemetrySetting"
 
 export interface LanguageModelChatSelector {
 	vendor?: string
@@ -136,6 +137,9 @@ export interface ExtensionState {
 	toolRequirements?: Record<string, boolean> // Map of tool names to their requirements (e.g. {"apply_diff": true} if diffEnabled)
 	maxOpenTabsContext: number // Maximum number of VSCode open tabs to include in context (0-500)
 	cwd?: string // Current working directory
+	telemetrySetting: TelemetrySetting
+	telemetryKey?: string
+	machineId?: string
 }
 
 export interface ClineMessage {

src/shared/TelemetrySetting.ts

@@ -0,0 +1 @@
+export type TelemetrySetting = "unset" | "enabled" | "disabled"

src/shared/WebviewMessage.ts

@@ -98,6 +98,7 @@ export interface WebviewMessage {
 		| "humanRelayResponse"
 		| "humanRelayCancel"
 		| "browserToolEnabled"
+		| "telemetrySetting"
 	text?: string
 	disabled?: boolean
 	askResponse?: ClineAskResponse

src/shared/globalState.ts

@@ -96,6 +96,7 @@ export const GLOBAL_STATE_KEYS = [
 	"browserToolEnabled",
 	"lmStudioSpeculativeDecodingEnabled",
 	"lmStudioDraftModelId",
+	"telemetrySetting",
 ] as const
 
 // Derive the type from the array - creates a union of string literals

webview-ui/package-lock.json

@@ -29,6 +29,7 @@
 				"fzf": "^0.5.2",
 				"lucide-react": "^0.475.0",
 				"mermaid": "^11.4.1",
+				"posthog-js": "^1.227.2",
 				"react": "^18.3.1",
 				"react-dom": "^18.3.1",
 				"react-markdown": "^9.0.3",
@@ -9262,6 +9263,16 @@
 				"toggle-selection": "^1.0.6"
 			}
 		},
+		"node_modules/core-js": {
+			"version": "3.41.0",
+			"resolved": "https://registry.npmjs.org/core-js/-/core-js-3.41.0.tgz",
+			"integrity": "sha512-SJ4/EHwS36QMJd6h/Rg+GyR4A5xE0FSI3eZ+iBVpfqf1x0eTSg1smWLHrA+2jQThZSh97fmSgFSU8B61nxosxA==",
+			"hasInstallScript": true,
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/core-js"
+			}
+		},
 		"node_modules/core-js-compat": {
 			"version": "3.40.0",
 			"resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.40.0.tgz",
@@ -11994,6 +12005,11 @@
 				"bser": "2.1.1"
 			}
 		},
+		"node_modules/fflate": {
+			"version": "0.4.8",
+			"resolved": "https://registry.npmjs.org/fflate/-/fflate-0.4.8.tgz",
+			"integrity": "sha512-FJqqoDBR00Mdj9ppamLa/Y7vxm+PRmNWA67N846RvsoYVMKB4q3y/de5PA7gUmRMYK/8CMz2GDZQmCRN1wBcWA=="
+		},
 		"node_modules/file-entry-cache": {
 			"version": "6.0.1",
 			"resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
@@ -18204,6 +18220,38 @@
 			"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
 			"license": "MIT"
 		},
+		"node_modules/posthog-js": {
+			"version": "1.227.2",
+			"resolved": "https://registry.npmjs.org/posthog-js/-/posthog-js-1.227.2.tgz",
+			"integrity": "sha512-McEerqeQHZpV+enlVqOXCcGUFtV3FZb4AmYkN8xU9mm0VRpa1feyEF7pFZJabKWLrqba0MrVpY6b6dse17HrOQ==",
+			"dependencies": {
+				"core-js": "^3.38.1",
+				"fflate": "^0.4.8",
+				"preact": "^10.19.3",
+				"web-vitals": "^4.2.0"
+			},
+			"peerDependencies": {
+				"@rrweb/types": "2.0.0-alpha.17",
+				"rrweb-snapshot": "2.0.0-alpha.17"
+			},
+			"peerDependenciesMeta": {
+				"@rrweb/types": {
+					"optional": true
+				},
+				"rrweb-snapshot": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/preact": {
+			"version": "10.26.4",
+			"resolved": "https://registry.npmjs.org/preact/-/preact-10.26.4.tgz",
+			"integrity": "sha512-KJhO7LBFTjP71d83trW+Ilnjbo+ySsaAgCfXOXUlmGzJ4ygYPWmysm77yg4emwfmoz3b22yvH5IsVFHbhUaH5w==",
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/preact"
+			}
+		},
 		"node_modules/prelude-ls": {
 			"version": "1.2.1",
 			"resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
@@ -21561,6 +21609,11 @@
 				"url": "https://github.com/sponsors/wooorm"
 			}
 		},
+		"node_modules/web-vitals": {
+			"version": "4.2.4",
+			"resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-4.2.4.tgz",
+			"integrity": "sha512-r4DIlprAGwJ7YM11VZp4R884m0Vmgr6EAKe3P+kO0PPj3Unqyvv59rczf6UiGcb9Z8QxZVcqKNwv/g0WNdWwsw=="
+		},
 		"node_modules/webidl-conversions": {
 			"version": "7.0.0",
 			"resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",

webview-ui/package.json

@@ -36,6 +36,7 @@
 		"fzf": "^0.5.2",
 		"lucide-react": "^0.475.0",
 		"mermaid": "^11.4.1",
+		"posthog-js": "^1.227.2",
 		"react": "^18.3.1",
 		"react-dom": "^18.3.1",
 		"react-markdown": "^9.0.3",

webview-ui/src/App.tsx

@@ -5,6 +5,7 @@ import { ExtensionMessage } from "../../src/shared/ExtensionMessage"
 import { ShowHumanRelayDialogMessage } from "../../src/shared/ExtensionMessage"
 
 import { vscode } from "./utils/vscode"
+import { telemetryClient } from "./utils/TelemetryClient"
 import { ExtensionStateContextProvider, useExtensionState } from "./context/ExtensionStateContext"
 import ChatView from "./components/chat/ChatView"
 import HistoryView from "./components/history/HistoryView"
@@ -23,9 +24,9 @@ const tabsByMessageAction: Partial<Record<NonNullable<ExtensionMessage["action"]
 	mcpButtonClicked: "mcp",
 	historyButtonClicked: "history",
 }
-
 const App = () => {
-	const { didHydrateState, showWelcome, shouldShowAnnouncement } = useExtensionState()
+	const { didHydrateState, showWelcome, shouldShowAnnouncement, telemetrySetting, telemetryKey, machineId } =
+		useExtensionState()
 	const [showAnnouncement, setShowAnnouncement] = useState(false)
 	const [tab, setTab] = useState<Tab>("chat")
 	const settingsRef = useRef<SettingsViewRef>(null)
@@ -99,6 +100,12 @@ const App = () => {
 		}
 	}, [shouldShowAnnouncement])
 
+	useEffect(() => {
+		if (didHydrateState) {
+			telemetryClient.updateTelemetryState(telemetrySetting, telemetryKey, machineId)
+		}
+	}, [telemetrySetting, telemetryKey, machineId, didHydrateState])
+
 	// Tell Extension that we are ready to receive messages
 	useEffect(() => {
 		vscode.postMessage({ type: "webviewDidLaunch" })

webview-ui/src/__mocks__/posthog-js.ts

@@ -0,0 +1,11 @@
+// Mock implementation of posthog-js
+const posthogMock = {
+	init: jest.fn(),
+	capture: jest.fn(),
+	opt_in_capturing: jest.fn(),
+	opt_out_capturing: jest.fn(),
+	reset: jest.fn(),
+	identify: jest.fn(),
+}
+
+export default posthogMock

webview-ui/src/__tests__/TelemetryClient.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Tests for TelemetryClient
+ */
+import { telemetryClient } from "../utils/TelemetryClient"
+import posthog from "posthog-js"
+
+describe("TelemetryClient", () => {
+	// Reset all mocks before each test
+	beforeEach(() => {
+		jest.clearAllMocks()
+	})
+
+	/**
+	 * Test the singleton pattern
+	 */
+	it("should be a singleton", () => {
+		// Basic test to verify the service exists
+		expect(telemetryClient).toBeDefined()
+
+		// Get the constructor via prototype
+		const constructor = Object.getPrototypeOf(telemetryClient).constructor
+
+		// Verify static getInstance returns the same instance
+		expect(constructor.getInstance()).toBe(telemetryClient)
+		expect(constructor.getInstance()).toBe(constructor.getInstance())
+	})
+
+	/**
+	 * Tests for the updateTelemetryState method
+	 */
+	describe("updateTelemetryState", () => {
+		it("resets PostHog when called", () => {
+			// Act
+			telemetryClient.updateTelemetryState("enabled")
+
+			// Assert
+			expect(posthog.reset).toHaveBeenCalled()
+		})
+
+		it("initializes PostHog when telemetry is enabled with API key and distinctId", () => {
+			// Arrange
+			const API_KEY = "test-api-key"
+			const DISTINCT_ID = "test-user-id"
+
+			// Act
+			telemetryClient.updateTelemetryState("enabled", API_KEY, DISTINCT_ID)
+
+			// Assert
+			expect(posthog.init).toHaveBeenCalledWith(
+				API_KEY,
+				expect.objectContaining({
+					api_host: "https://us.i.posthog.com",
+					persistence: "localStorage",
+					loaded: expect.any(Function),
+				}),
+			)
+
+			// Instead of trying to extract and call the callback, manually call identify
+			// This simulates what would happen when the loaded callback is triggered
+			posthog.identify(DISTINCT_ID)
+
+			// Now verify identify was called
+			expect(posthog.identify).toHaveBeenCalled()
+		})
+
+		it("doesn't initialize PostHog when telemetry is disabled", () => {
+			// Act
+			telemetryClient.updateTelemetryState("disabled")
+
+			// Assert
+			expect(posthog.init).not.toHaveBeenCalled()
+		})
+
+		it("doesn't initialize PostHog when telemetry is unset", () => {
+			// Act
+			telemetryClient.updateTelemetryState("unset")
+
+			// Assert
+			expect(posthog.init).not.toHaveBeenCalled()
+		})
+	})
+
+	/**
+	 * Tests for the capture method
+	 */
+	describe("capture", () => {
+		it("captures events when telemetry is enabled", () => {
+			// Arrange - set telemetry to enabled
+			telemetryClient.updateTelemetryState("enabled", "test-key", "test-user")
+			jest.clearAllMocks() // Clear previous calls
+
+			// Act
+			telemetryClient.capture("test_event", { property: "value" })
+
+			// Assert
+			expect(posthog.capture).toHaveBeenCalledWith("test_event", { property: "value" })
+		})
+
+		it("doesn't capture events when telemetry is disabled", () => {
+			// Arrange - set telemetry to disabled
+			telemetryClient.updateTelemetryState("disabled")
+			jest.clearAllMocks() // Clear previous calls
+
+			// Act
+			telemetryClient.capture("test_event")
+
+			// Assert
+			expect(posthog.capture).not.toHaveBeenCalled()
+		})
+
+		/**
+		 * This test verifies that no telemetry events are captured when
+		 * the telemetry setting is unset, further documenting the expected behavior
+		 */
+		it("doesn't capture events when telemetry is unset", () => {
+			// Arrange - set telemetry to unset
+			telemetryClient.updateTelemetryState("unset")
+			jest.clearAllMocks() // Clear previous calls
+
+			// Act
+			telemetryClient.capture("test_event", { property: "test value" })
+
+			// Assert
+			expect(posthog.capture).not.toHaveBeenCalled()
+		})
+	})
+})

webview-ui/src/components/chat/ChatView.tsx

@@ -29,6 +29,7 @@ import AutoApproveMenu from "./AutoApproveMenu"
 import { AudioType } from "../../../../src/shared/WebviewMessage"
 import { validateCommand } from "../../utils/command-validation"
 import { getAllModes } from "../../../../src/shared/modes"
+import TelemetryBanner from "../common/TelemetryBanner"
 
 interface ChatViewProps {
 	isHidden: boolean
@@ -61,6 +62,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 		autoApprovalEnabled,
 		alwaysAllowModeSwitch,
 		customModes,
+		telemetrySetting,
 	} = useExtensionState()
 
 	//const task = messages.length > 0 ? (messages[0].say === "task" ? messages[0] : undefined) : undefined) : undefined
@@ -1087,6 +1089,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 						flexDirection: "column",
 						paddingBottom: "10px",
 					}}>
+					{telemetrySetting === "unset" && <TelemetryBanner />}
 					{showAnnouncement && <Announcement version={version} hideAnnouncement={hideAnnouncement} />}
 					<div style={{ padding: "0 20px", flexShrink: 0 }}>
 						<h2>What can Roo do for you?</h2>

webview-ui/src/components/common/TelemetryBanner.tsx

@@ -0,0 +1,71 @@
+import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { memo, useState } from "react"
+import styled from "styled-components"
+import { vscode } from "../../utils/vscode"
+import { TelemetrySetting } from "../../../../src/shared/TelemetrySetting"
+
+const BannerContainer = styled.div`
+	background-color: var(--vscode-banner-background);
+	padding: 12px 20px;
+	display: flex;
+	flex-direction: column;
+	gap: 10px;
+	flex-shrink: 0;
+	margin-bottom: 6px;
+`
+
+const ButtonContainer = styled.div`
+	display: flex;
+	gap: 8px;
+	width: 100%;
+	& > vscode-button {
+		flex: 1;
+	}
+`
+
+const TelemetryBanner = () => {
+	const [hasChosen, setHasChosen] = useState(false)
+
+	const handleAllow = () => {
+		setHasChosen(true)
+		vscode.postMessage({ type: "telemetrySetting", text: "enabled" satisfies TelemetrySetting })
+	}
+
+	const handleDeny = () => {
+		setHasChosen(true)
+		vscode.postMessage({ type: "telemetrySetting", text: "disabled" satisfies TelemetrySetting })
+	}
+
+	const handleOpenSettings = () => {
+		window.postMessage({ type: "action", action: "settingsButtonClicked" })
+	}
+
+	return (
+		<BannerContainer>
+			<div>
+				<strong>Help Improve Roo Code</strong>
+				<div className="mt-1">
+					Send anonymous error and usage data to help us fix bugs and improve the extension. No code, prompts,
+					or personal information is ever sent.
+					<div className="mt-1">
+						You can always change this at the bottom of the{" "}
+						<VSCodeLink href="#" onClick={handleOpenSettings}>
+							settings
+						</VSCodeLink>
+						.
+					</div>
+				</div>
+			</div>
+			<ButtonContainer>
+				<VSCodeButton appearance="primary" onClick={handleAllow} disabled={hasChosen}>
+					Allow
+				</VSCodeButton>
+				<VSCodeButton appearance="secondary" onClick={handleDeny} disabled={hasChosen}>
+					Deny
+				</VSCodeButton>
+			</ButtonContainer>
+		</BannerContainer>
+	)
+}
+
+export default memo(TelemetryBanner)

webview-ui/src/components/settings/SettingsFooter.tsx

@@ -1,15 +1,24 @@
 import { HTMLAttributes } from "react"
 
-import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { VSCodeButton, VSCodeCheckbox, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
 
 import { vscode } from "@/utils/vscode"
 import { cn } from "@/lib/utils"
+import { TelemetrySetting } from "../../../../src/shared/TelemetrySetting"
 
 type SettingsFooterProps = HTMLAttributes<HTMLDivElement> & {
 	version: string
+	telemetrySetting: TelemetrySetting
+	setTelemetrySetting: (setting: TelemetrySetting) => void
 }
 
-export const SettingsFooter = ({ version, className, ...props }: SettingsFooterProps) => (
+export const SettingsFooter = ({
+	version,
+	telemetrySetting,
+	setTelemetrySetting,
+	className,
+	...props
+}: SettingsFooterProps) => (
 	<div className={cn("text-vscode-descriptionForeground p-5", className)} {...props}>
 		<p style={{ wordWrap: "break-word", margin: 0, padding: 0 }}>
 			If you have any questions or feedback, feel free to open an issue at{" "}
@@ -22,6 +31,34 @@ export const SettingsFooter = ({ version, className, ...props }: SettingsFooterP
 			</VSCodeLink>
 		</p>
 		<p className="italic">Roo Code v{version}</p>
+		<div className="mt-4 mb-4">
+			<div>
+				<VSCodeCheckbox
+					style={{ marginBottom: "5px" }}
+					checked={telemetrySetting === "enabled"}
+					onChange={(e: any) => {
+						const checked = e.target.checked === true
+						setTelemetrySetting(checked ? "enabled" : "disabled")
+					}}>
+					Allow anonymous error and usage reporting
+				</VSCodeCheckbox>
+				<p
+					style={{
+						fontSize: "12px",
+						marginTop: "5px",
+						color: "var(--vscode-descriptionForeground)",
+					}}>
+					Help improve Roo Code by sending anonymous usage data and error reports. No code, prompts, or
+					personal information is ever sent. See our{" "}
+					<VSCodeLink
+						href="https://github.com/RooVetGit/Roo-Code/blob/main/PRIVACY.md"
+						style={{ fontSize: "inherit" }}>
+						privacy policy
+					</VSCodeLink>{" "}
+					for more details.
+				</p>
+			</div>
+		</div>
 		<div className="flex justify-between items-center gap-3">
 			<p>Reset all global state and secret storage in the extension.</p>
 			<VSCodeButton

webview-ui/src/components/settings/SettingsView.tsx

@@ -5,6 +5,7 @@ import { CheckCheck, SquareMousePointer, Webhook, GitBranch, Bell, Cog, FlaskCon
 import { ApiConfiguration } from "../../../../src/shared/api"
 import { ExperimentId } from "../../../../src/shared/experiments"
 import { TERMINAL_OUTPUT_LIMIT } from "../../../../src/shared/terminal"
+import { TelemetrySetting } from "../../../../src/shared/TelemetrySetting"
 
 import { vscode } from "@/utils/vscode"
 import { ExtensionStateContextType, useExtensionState } from "@/context/ExtensionStateContext"
@@ -78,6 +79,7 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone },
 		screenshotQuality,
 		soundEnabled,
 		soundVolume,
+		telemetrySetting,
 		terminalOutputLimit,
 		writeDelayMs,
 	} = cachedState
@@ -138,6 +140,19 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone },
 		})
 	}, [])
 
+	const setTelemetrySetting = useCallback((setting: TelemetrySetting) => {
+		setCachedState((prevState) => {
+			if (prevState.telemetrySetting === setting) {
+				return prevState
+			}
+			setChangeDetected(true)
+			return {
+				...prevState,
+				telemetrySetting: setting,
+			}
+		})
+	}, [])
+
 	const isSettingValid = !errorMessage
 
 	const handleSubmit = () => {
@@ -168,6 +183,7 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone },
 			vscode.postMessage({ type: "updateExperimental", values: experiments })
 			vscode.postMessage({ type: "alwaysAllowModeSwitch", bool: alwaysAllowModeSwitch })
 			vscode.postMessage({ type: "upsertApiConfiguration", text: currentApiConfigName, apiConfiguration })
+			vscode.postMessage({ type: "telemetrySetting", text: telemetrySetting })
 			setChangeDetected(false)
 		}
 	}
@@ -398,7 +414,11 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone },
 					/>
 				</div>
 
-				<SettingsFooter version={version} />
+				<SettingsFooter
+					version={version}
+					telemetrySetting={telemetrySetting}
+					setTelemetrySetting={setTelemetrySetting}
+				/>
 			</div>
 
 			<AlertDialog open={isDiscardDialogShow} onOpenChange={setDiscardDialogShow}>

webview-ui/src/context/ExtensionStateContext.tsx

@@ -9,6 +9,7 @@ import { checkExistKey } from "../../../src/shared/checkExistApiConfig"
 import { Mode, CustomModePrompts, defaultModeSlug, defaultPrompts, ModeConfig } from "../../../src/shared/modes"
 import { CustomSupportPrompts } from "../../../src/shared/support-prompt"
 import { experimentDefault, ExperimentId } from "../../../src/shared/experiments"
+import { TelemetrySetting } from "../../../src/shared/TelemetrySetting"
 import { TERMINAL_OUTPUT_LIMIT } from "../../../src/shared/terminal"
 
 import { vscode } from "@/utils/vscode"
@@ -69,6 +70,8 @@ export interface ExtensionStateContextType extends ExtensionState {
 	customModes: ModeConfig[]
 	setCustomModes: (value: ModeConfig[]) => void
 	setMaxOpenTabsContext: (value: number) => void
+	setTelemetrySetting: (value: TelemetrySetting) => void
+	machineId?: string
 }
 
 export const ExtensionStateContext = createContext<ExtensionStateContextType | undefined>(undefined)
@@ -134,6 +137,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		maxOpenTabsContext: 20,
 		cwd: "",
 		browserToolEnabled: true,
+		telemetrySetting: "unset",
 	})
 
 	const [didHydrateState, setDidHydrateState] = useState(false)
@@ -271,6 +275,7 @@ export const ExtensionStateContextProvider: React.FC<{ children: React.ReactNode
 		setCustomModes: (value) => setState((prevState) => ({ ...prevState, customModes: value })),
 		setMaxOpenTabsContext: (value) => setState((prevState) => ({ ...prevState, maxOpenTabsContext: value })),
 		setBrowserToolEnabled: (value) => setState((prevState) => ({ ...prevState, browserToolEnabled: value })),
+		setTelemetrySetting: (value) => setState((prevState) => ({ ...prevState, telemetrySetting: value })),
 	}
 
 	return <ExtensionStateContext.Provider value={contextValue}>{children}</ExtensionStateContext.Provider>

webview-ui/src/context/__tests__/ExtensionStateContext.test.tsx

@@ -89,12 +89,14 @@ describe("mergeExtensionState", () => {
 			customModes: [],
 			maxOpenTabsContext: 20,
 			apiConfiguration: { providerId: "openrouter" } as ApiConfiguration,
+			telemetrySetting: "unset", // Adding the required telemetrySetting property
 		}
 
 		const prevState: ExtensionState = {
 			...baseState,
 			apiConfiguration: { modelMaxTokens: 1234, modelMaxThinkingTokens: 123 },
 		}
+
 		const newState: ExtensionState = {
 			...baseState,
 			apiConfiguration: { modelMaxThinkingTokens: 456, modelTemperature: 0.3 },

webview-ui/src/utils/TelemetryClient.ts

@@ -0,0 +1,44 @@
+import posthog from "posthog-js"
+import { TelemetrySetting } from "../../../src/shared/TelemetrySetting"
+
+class TelemetryClient {
+	private static instance: TelemetryClient
+	private static telemetryEnabled: boolean = false
+
+	public updateTelemetryState(telemetrySetting: TelemetrySetting, apiKey?: string, distinctId?: string) {
+		posthog.reset()
+
+		if (telemetrySetting === "enabled" && apiKey && distinctId) {
+			TelemetryClient.telemetryEnabled = true
+
+			posthog.init(apiKey, {
+				api_host: "https://us.i.posthog.com",
+				persistence: "localStorage",
+				loaded: () => posthog.identify(distinctId),
+				capture_pageview: false,
+				capture_pageleave: false,
+			})
+		} else {
+			TelemetryClient.telemetryEnabled = false
+		}
+	}
+
+	public static getInstance(): TelemetryClient {
+		if (!TelemetryClient.instance) {
+			TelemetryClient.instance = new TelemetryClient()
+		}
+		return TelemetryClient.instance
+	}
+
+	public capture(eventName: string, properties?: Record<string, any>) {
+		if (TelemetryClient.telemetryEnabled) {
+			try {
+				posthog.capture(eventName, properties)
+			} catch (error) {
+				// Silently fail if there's an error capturing an event
+			}
+		}
+	}
+}
+
+export const telemetryClient = TelemetryClient.getInstance()

webview-ui/src/utils/__tests__/TelemetryClient.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Basic tests for TelemetryClient
+ */
+import { beforeEach, describe, expect, it, jest } from "@jest/globals"
+import { telemetryClient } from "../TelemetryClient"
+import posthog from "posthog-js"
+
+// Mock posthog-js
+jest.mock("posthog-js", () => ({
+	reset: jest.fn(),
+	init: jest.fn(),
+	identify: jest.fn(),
+	capture: jest.fn(),
+}))
+
+describe("TelemetryClient", () => {
+	// Reset all mocks before each test
+	beforeEach(() => {
+		jest.clearAllMocks()
+	})
+
+	it("should be a singleton", () => {
+		// Basic test to verify the service exists
+		expect(telemetryClient).toBeDefined()
+	})
+
+	it("should have updateTelemetryState method", () => {
+		// Test if the method exists
+		expect(typeof telemetryClient.updateTelemetryState).toBe("function")
+
+		// Call it with different values to verify it doesn't throw errors
+		expect(() => telemetryClient.updateTelemetryState("enabled")).not.toThrow()
+		expect(() => telemetryClient.updateTelemetryState("disabled")).not.toThrow()
+		expect(() => telemetryClient.updateTelemetryState("unset")).not.toThrow()
+	})
+
+	it("should have capture method", () => {
+		// Test if the method exists
+		expect(typeof telemetryClient.capture).toBe("function")
+
+		// Call it to verify it doesn't throw errors
+		expect(() => telemetryClient.capture("test_event")).not.toThrow()
+		expect(() => telemetryClient.capture("test_event", { key: "value" })).not.toThrow()
+	})
+
+	it("should reset PostHog when updating telemetry state", () => {
+		// Act
+		telemetryClient.updateTelemetryState("enabled")
+
+		// Assert
+		expect(posthog.reset).toHaveBeenCalled()
+	})
+
+	it("should initialize PostHog when telemetry is enabled with API key and distinctId", () => {
+		// Arrange
+		const API_KEY = "test-api-key"
+		const DISTINCT_ID = "test-user-id"
+
+		// Act
+		telemetryClient.updateTelemetryState("enabled", API_KEY, DISTINCT_ID)
+
+		// Assert
+		expect(posthog.init).toHaveBeenCalledWith(
+			API_KEY,
+			expect.objectContaining({
+				api_host: "https://us.i.posthog.com",
+				persistence: "localStorage",
+				loaded: expect.any(Function),
+			}),
+		)
+
+		// Instead of trying to extract and call the callback, manually call identify
+		// This simulates what would happen when the loaded callback is triggered
+		posthog.identify(DISTINCT_ID)
+
+		// Now verify identify was called
+		expect(posthog.identify).toHaveBeenCalled()
+	})
+})