Merge pull request #410 from Kilo-Org/mark/telemetry-implementation

feat: implement proxy-based telemetry for VS Code extension

Author: Mark IJbema

AGENTS.md

@@ -153,6 +153,7 @@ We regularly merge upstream changes from opencode. To minimize merge conflicts a
 2. **Minimize changes to shared files** - When you must modify files that exist in upstream opencode, keep changes as small and isolated as possible.
 
 3. **Use `kilocode_change` markers** - When modifying shared code, mark your changes with `kilocode_change` comments so they can be easily identified during merges.
+   Do not use these markers in files within directories with kilo in the name
 
 4. **Avoid restructuring upstream code** - Don't refactor or reorganize code that comes from opencode unless absolutely necessary.
 

packages/kilo-telemetry/src/__tests__/telemetry.test.ts

@@ -114,7 +114,11 @@ describe("PostHogSpanExporter", () => {
   }
 
   test("export returns success when disabled", () => {
-    const exporter = new PostHogSpanExporter(createMockPostHogClient())
+    const exporter = new PostHogSpanExporter(createMockPostHogClient(), {
+      appName: "test",
+      appVersion: "1.0.0",
+      platform: "test",
+    })
     exporter.setEnabled(false)
 
     const span = createMockSpan("ai.generateText", { "ai.model.id": "gpt-4" })
@@ -131,7 +135,11 @@ describe("PostHogSpanExporter", () => {
   test("sensitive attributes are not included in exported properties", () => {
     // This test verifies the filtering logic by checking the SENSITIVE_ATTRIBUTES set
     // and the mapAttributes method behavior through the export function
-    const exporter = new PostHogSpanExporter(createMockPostHogClient())
+    const exporter = new PostHogSpanExporter(createMockPostHogClient(), {
+      appName: "test",
+      appVersion: "1.0.0",
+      platform: "test",
+    })
 
     // Create a span with both safe and sensitive attributes
     const span = createMockSpan("ai.generateText", {

packages/kilo-telemetry/src/identity.ts

@@ -14,6 +14,12 @@ export namespace Identity {
   export async function getMachineId(): Promise<string> {
     if (machineId) return machineId
 
+    const override = process.env.KILO_MACHINE_ID
+    if (override) {
+      machineId = override
+      return machineId
+    }
+
     const filepath = path.join(dataPath, "telemetry-id")
     const file = Bun.file(filepath)
 

packages/kilo-telemetry/src/otel-exporter.ts

@@ -38,14 +38,22 @@ const SENSITIVE_ATTRIBUTES = new Set([
 export class PostHogSpanExporter implements SpanExporter {
   private client: PostHog
   private enabled = true
-  private appName = "kilo-cli"
-  private appVersion = "unknown"
-
-  constructor(client: PostHog, options?: { appVersion?: string }) {
+  private appName: string
+  private appVersion: string
+  private platform: string
+  private editorName?: string
+  private vscodeVersion?: string
+
+  constructor(
+    client: PostHog,
+    options: { appName: string; appVersion: string; platform: string; editorName?: string; vscodeVersion?: string },
+  ) {
     this.client = client
-    if (options?.appVersion) {
-      this.appVersion = options.appVersion
-    }
+    this.appName = options.appName
+    this.appVersion = options.appVersion
+    this.platform = options.platform
+    this.editorName = options.editorName
+    this.vscodeVersion = options.vscodeVersion
   }
 
   setEnabled(value: boolean) {
@@ -82,7 +90,9 @@ export class PostHogSpanExporter implements SpanExporter {
     const properties: Record<string, unknown> = {
       appName: this.appName,
       appVersion: this.appVersion,
-      platform: process.platform,
+      platform: this.platform,
+      ...(this.editorName && { editorName: this.editorName }),
+      ...(this.vscodeVersion && { vscodeVersion: this.vscodeVersion }),
       $ai_trace_id: span.spanContext().traceId,
       $ai_span_id: span.spanContext().spanId,
       $ai_span_name: name,

packages/kilo-telemetry/src/telemetry.ts

@@ -8,6 +8,8 @@ export interface TelemetryProperties {
   appName: string
   appVersion: string
   platform: string
+  editorName?: string
+  vscodeVersion?: string
 }
 
 export namespace Telemetry {
@@ -25,11 +27,32 @@ export namespace Telemetry {
     Identity.setDataPath(options.dataPath)
     props.appVersion = options.version
 
+    const app = process.env.KILO_APP_NAME
+    if (app) props.appName = app
+    const editor = process.env.KILO_EDITOR_NAME
+    if (editor) props.editorName = editor
+    const platform = process.env.KILO_PLATFORM
+    if (platform) props.platform = platform
+    const version = process.env.KILO_APP_VERSION
+    if (version) props.appVersion = version
+    const vscodeVersion = process.env.KILO_VSCODE_VERSION
+    if (vscodeVersion) props.vscodeVersion = vscodeVersion
+
     Client.init()
-    Client.setEnabled(options.enabled)
+
+    const level = process.env.KILO_TELEMETRY_LEVEL
+    const enabled = level ? level === "all" : options.enabled
+    Client.setEnabled(enabled)
 
     // Initialize OpenTelemetry tracer for AI SDK spans
-    TracerSetup.init({ version: options.version, enabled: options.enabled })
+    TracerSetup.init({
+      version: props.appVersion,
+      enabled,
+      appName: props.appName,
+      platform: props.platform,
+      editorName: props.editorName,
+      vscodeVersion: props.vscodeVersion,
+    })
 
     await Identity.getMachineId()
 

packages/kilo-telemetry/src/tracer.ts

@@ -11,20 +11,33 @@ let exporter: PostHogSpanExporter | null = null
 let tracer: Tracer | null = null
 
 export namespace TracerSetup {
-  export function init(options: { version: string; enabled: boolean }): Tracer {
+  export function init(options: {
+    version: string
+    enabled: boolean
+    appName: string
+    platform: string
+    editorName?: string
+    vscodeVersion?: string
+  }): Tracer {
     if (tracer) return tracer
 
     const client = Client.getClient()
     if (!client) {
       throw new Error("PostHog client not initialized. Call Client.init() first.")
     }
 
-    exporter = new PostHogSpanExporter(client, { appVersion: options.version })
+    exporter = new PostHogSpanExporter(client, {
+      appName: options.appName,
+      appVersion: options.version,
+      platform: options.platform,
+      editorName: options.editorName,
+      vscodeVersion: options.vscodeVersion,
+    })
     exporter.setEnabled(options.enabled)
 
     provider = new NodeTracerProvider({
       resource: new Resource({
-        [ATTR_SERVICE_NAME]: "kilo-cli",
+        [ATTR_SERVICE_NAME]: options.appName,
         [ATTR_SERVICE_VERSION]: options.version,
       }),
       spanProcessors: [new SimpleSpanProcessor(exporter)],
@@ -34,7 +47,7 @@ export namespace TracerSetup {
     provider.register()
 
     // Get tracer from our provider
-    tracer = provider.getTracer("kilo-cli", options.version)
+    tracer = provider.getTracer(options.appName, options.version)
 
     return tracer
   }

packages/kilo-vscode/docs/non-agent-features/telemetry.md

@@ -111,12 +111,12 @@ All events are defined in `TelemetryEventName` enum (`packages/types/src/telemet
 
 ### 3.1 Task Lifecycle
 
-| Event                  | Properties                          | Capture Method                 |
-| ---------------------- | ----------------------------------- | ------------------------------ |
-| `Task Created`         | `taskId`                            | `captureTaskCreated()`         |
-| `Task Reopened`        | `taskId`                            | `captureTaskRestarted()`       |
-| `Task Completed`       | `taskId`                            | `captureTaskCompleted()`       |
-| `Conversation Message` | `taskId`, `source` (user/assistant) | `captureConversationMessage()` |
+| Event                  | Properties                          | Capture Method                                              |
+| ---------------------- | ----------------------------------- | ----------------------------------------------------------- |
+| `Task Created`         | `taskId`                            | `TelemetryProxy.capture(TelemetryEventName.TASK_CREATED)`         |
+| `Task Reopened`        | `taskId`                            | `TelemetryProxy.capture(TelemetryEventName.TASK_RESTARTED)`       |
+| `Task Completed`       | `taskId`                            | `TelemetryProxy.capture(TelemetryEventName.TASK_COMPLETED)`       |
+| `Conversation Message` | `taskId`, `source` (user/assistant) | `TelemetryProxy.capture(TelemetryEventName.TASK_CONVERSATION_MESSAGE)` |
 
 ### 3.2 LLM & AI
 
@@ -307,15 +307,15 @@ Both have type guards (`isApiProviderError()`, `isConsecutiveMistakeError()`) an
 ## 7. Implementation Recommendations for New Extension
 
 1. **Use `kilo-telemetry` via CLI proxy** — all PostHog communication goes through the CLI's `POST /telemetry/capture` endpoint. The extension does not include `posthog-node` or `posthog-js` directly.
-2. **Singleton service pattern** — single `TelemetryService` instance, multiple pluggable clients
+2. **Singleton pattern** — single `TelemetryProxy` instance that sends to CLI + logs to console, no pluggable clients
 3. **Properties provider pattern** — `KiloProvider` implements `TelemetryPropertiesProvider` to inject VS Code context into every event
-4. **Typed events** — all event names in an enum, with typed capture methods on the service
-5. **Event subscription/filtering** — clients can include/exclude specific events
-6. **Property filtering** — per-client property filtering (privacy controls)
+4. **Typed events** — all event names in an enum, callers use `TelemetryProxy.capture(TelemetryEventName.XXX, props)`
+5. **Event filtering** — `TelemetryProxy` can include/exclude specific events before forwarding to CLI
+6. **Property filtering** — privacy controls applied before forwarding to CLI
 7. **Dual opt-in** — respect both IDE-level and extension-level telemetry settings
 8. **Identity upgrade** — anonymous by default, upgrade to user identity on auth
 9. **Graceful degradation** — never crash on telemetry failures; all capture calls are fire-and-forget
-10. **Debug client** — separate console-logging client for development
+10. **Console logging** — `TelemetryProxy` logs events to console in development mode
 
 ---
 

packages/kilo-vscode/script/local-bin.ts

@@ -28,18 +28,31 @@ function log(msg: string) {
   console.log(`[local-bin] ${msg}`)
 }
 
+function platformTag(): string {
+  const os = process.platform === "win32" ? "windows" : process.platform
+  return `cli-${os}-${process.arch}`
+}
+
 async function findKiloBinaryInOpencodeDist(): Promise<string | null> {
   const distDir = join(opencodeDir, "dist")
 
-  // Check if dist directory exists using readdirSync
   try {
     readdirSync(distDir)
   } catch {
     return null
   }
 
-  // Expected: packages/opencode/dist/@kilocode/cli-<platform>/bin/kilo
-  // But keep it flexible: find any dist/**/bin/kilo
+  // Prefer the binary matching the current platform (e.g. cli-darwin-arm64)
+  const tag = platformTag()
+  const preferred = join(distDir, `@kilocode`, tag, "bin", "kilo")
+  try {
+    statSync(preferred)
+    return preferred
+  } catch {
+    // fall through to generic search
+  }
+
+  // Fallback: find any dist/**/bin/kilo
   const queue = [distDir]
   while (queue.length) {
     const dir = queue.pop()

packages/kilo-vscode/src/KiloProvider.ts

@@ -4,8 +4,9 @@ import { type HttpClient, type SessionInfo, type SSEEvent, type KiloConnectionSe
 import { handleChatCompletionRequest } from "./services/autocomplete/chat-autocomplete/handleChatCompletionRequest"
 import { handleChatCompletionAccepted } from "./services/autocomplete/chat-autocomplete/handleChatCompletionAccepted"
 import { buildWebviewHtml } from "./utils"
+import { TelemetryProxy, type TelemetryPropertiesProvider } from "./services/telemetry"
 
-export class KiloProvider implements vscode.WebviewViewProvider {
+export class KiloProvider implements vscode.WebviewViewProvider, TelemetryPropertiesProvider {
   public static readonly viewType = "kilo-code.new.sidebarView"
 
   private webview: vscode.Webview | null = null
@@ -36,7 +37,21 @@ export class KiloProvider implements vscode.WebviewViewProvider {
   constructor(
     private readonly extensionUri: vscode.Uri,
     private readonly connectionService: KiloConnectionService,
-  ) {}
+  ) {
+    TelemetryProxy.getInstance().setProvider(this)
+  }
+
+  getTelemetryProperties(): Record<string, unknown> {
+    return {
+      appName: "kilo-code",
+      appVersion: this.extensionVersion,
+      platform: "vscode",
+      editorName: vscode.env.appName,
+      vscodeVersion: vscode.version,
+      machineId: vscode.env.machineId,
+      vscodeIsTelemetryEnabled: vscode.env.isTelemetryEnabled,
+    }
+  }
 
   /**
    * Convenience getter that returns the shared HttpClient or null if not yet connected.
@@ -386,6 +401,9 @@ export class KiloProvider implements vscode.WebviewViewProvider {
         case "resetAllSettings":
           await this.handleResetAllSettings()
           break
+        case "telemetry":
+          TelemetryProxy.capture(message.event, message.properties)
+          break
       }
     })
   }

packages/kilo-vscode/src/extension.ts

@@ -5,21 +5,28 @@ import { EXTENSION_DISPLAY_NAME } from "./constants"
 import { KiloConnectionService } from "./services/cli-backend"
 import { registerAutocompleteProvider } from "./services/autocomplete"
 import { BrowserAutomationService } from "./services/browser-automation"
+import { TelemetryProxy } from "./services/telemetry"
 
 export function activate(context: vscode.ExtensionContext) {
   console.log("Kilo Code extension is now active")
 
+  const telemetry = TelemetryProxy.getInstance()
+
   // Create shared connection service (one server for all webviews)
   const connectionService = new KiloConnectionService(context)
 
   // Create browser automation service (manages Playwright MCP registration)
   const browserAutomationService = new BrowserAutomationService(connectionService)
   browserAutomationService.syncWithSettings()
 
-  // Re-register browser automation MCP server on CLI backend reconnect
+  // Re-register browser automation MCP server on CLI backend reconnect and configure telemetry
   const unsubscribeStateChange = connectionService.onStateChange((state) => {
     if (state === "connected") {
       browserAutomationService.reregisterIfEnabled()
+      const config = connectionService.getServerConfig()
+      if (config) {
+        telemetry.configure(config.baseUrl, config.password)
+      }
     }
   })
 
@@ -83,7 +90,9 @@ export function activate(context: vscode.ExtensionContext) {
   })
 }
 
-export function deactivate() {}
+export function deactivate() {
+  TelemetryProxy.getInstance().shutdown()
+}
 
 async function openKiloInNewTab(context: vscode.ExtensionContext, connectionService: KiloConnectionService) {
   const lastCol = Math.max(...vscode.window.visibleTextEditors.map((e) => e.viewColumn || 0), 0)