feat: track folder count in telemetry events for file operations

mnismt · mnismt · commit 4911c9fb80ee · 2025-03-26T16:53:48.000+07:00
diff --git a/TELEMETRY.md b/TELEMETRY.md
@@ -17,9 +17,9 @@ The following usage information is collected and reported:
 - When selections are added to Cody (excluding selected content)
 - When smart selections are added to Cody (excluding selected content)
 
-#### File Counting
+#### File & Folder Counting
 
-We track the total number of files added to Cody, but **we never read or store the actual contents of these files**. This helps us understand usage patterns without compromising your privacy. The count is purely numerical and anonymized.
+We track the total number of files & folders added to Cody, but **we never read or store the actual contents of these files**. This helps us understand usage patterns without compromising your privacy. The count is purely numerical and anonymized.
 
 ### Custom Commands
 
diff --git a/src/commands/addToCody.ts b/src/commands/addToCody.ts
@@ -1,8 +1,9 @@
+import * as path from 'path'
 import * as vscode from 'vscode'
 import { TELEMETRY_EVENTS } from '../constants/telemetry'
 import { executeMentionFileCommand } from '../core/cody/commands'
 import { formatFileTree, getWorkspaceFileTree } from '../core/filesystem/operations'
-import { getSelectedFileUris } from '../core/filesystem/processor'
+import { getSelectedFileUris, getSelectedFolderCount } from '../core/filesystem/processor'
 import { createProvider } from '../core/llm'
 import { createCompletionRequestMessages, parseLLMResponse } from '../core/llm/utils'
 import { TelemetryService } from '../services/telemetry.service'
@@ -18,7 +19,8 @@ export async function addFile(folderUri: vscode.Uri) {
     )
 
     telemetry.trackEvent(TELEMETRY_EVENTS.FILES.ADD_FILE, {
-      fileCount
+      fileCount,
+      folderCount: 1 // Single file operation always has 1 folder
     })
   } catch (error: any) {
     vscode.window.showErrorMessage(`Failed to add file to Cody: ${error.message}`)
@@ -28,17 +30,19 @@ export async function addFile(folderUri: vscode.Uri) {
 export async function addSelection(folderUris: vscode.Uri[], recursive = false) {
   const telemetry = TelemetryService.getInstance()
   try {
-    const files = await getSelectedFileUris(folderUris, {
+    const { folderCount, fileUris } = await getSelectedFolderCount(folderUris, {
       recursive,
       progressTitle: 'Adding selection to Cody'
     })
-    const fileCount = (await Promise.all(files.map(executeMentionFileCommand))).reduce(
+
+    const fileCount = (await Promise.all(fileUris.map(executeMentionFileCommand))).reduce(
       getSuccessCount,
       0
     )
 
     telemetry.trackEvent(TELEMETRY_EVENTS.FILES.ADD_SELECTION, {
       fileCount,
+      folderCount,
       recursive
     })
   } catch (error: any) {
@@ -49,17 +53,19 @@ export async function addSelection(folderUris: vscode.Uri[], recursive = false)
 export async function addFolder(folderUri: vscode.Uri, recursive = true) {
   const telemetry = TelemetryService.getInstance()
   try {
-    const files = await getSelectedFileUris([folderUri], {
+    const { folderCount, fileUris } = await getSelectedFolderCount([folderUri], {
       recursive,
       progressTitle: 'Adding folder to Cody'
     })
-    const fileCount = (await Promise.all(files.map(executeMentionFileCommand))).reduce(
+
+    const fileCount = (await Promise.all(fileUris.map(executeMentionFileCommand))).reduce(
       getSuccessCount,
       0
     )
 
     telemetry.trackEvent(TELEMETRY_EVENTS.FILES.ADD_FOLDER, {
       fileCount,
+      folderCount,
       recursive
     })
   } catch (error: any) {
@@ -127,13 +133,22 @@ export async function addFilesSmart(folderUris: vscode.Uri[], context: vscode.Ex
           // Convert paths to URIs and add to Cody
           const selectedFileUris = selectedFiles.map(filePath => vscode.Uri.file(filePath))
 
+          // Count unique folders from the selected files
+          const uniqueFolders = new Set<string>()
+          selectedFiles.forEach(filePath => {
+            const dirPath = path.dirname(filePath)
+            uniqueFolders.add(dirPath)
+          })
+          const folderCount = uniqueFolders.size
+
           progress.report({ increment: 15, message: 'Adding files to Cody...' })
           const fileCount = (
             await Promise.all(selectedFileUris.map(executeMentionFileCommand))
           ).reduce(getSuccessCount, 0)
 
           telemetry.trackEvent(TELEMETRY_EVENTS.FILES.ADD_SMART_SELECTION, {
-            fileCount
+            fileCount,
+            folderCount
           })
 
           // Provide feedback to the user.
@@ -151,9 +166,6 @@ export async function addFilesSmart(folderUris: vscode.Uri[], context: vscode.Ex
               modal: true
             }
           )
-          telemetry.trackEvent(TELEMETRY_EVENTS.FILES.ADD_SMART_SELECTION, {
-            fileCount
-          })
         } catch (error: any) {
           vscode.window.showErrorMessage(`Failed to add files smart to Cody: ${error.message}`)
           throw error
diff --git a/src/core/filesystem/processor.ts b/src/core/filesystem/processor.ts
@@ -69,3 +69,127 @@ export async function getSelectedFileUris(
 
   return fileUris
 }
+
+/**
+ * Gets both the selected file URIs and counts the number of folders processed
+ * @param uris Input URIs to process
+ * @param options Processing configuration options
+ * @returns Object containing folder count and file URIs
+ */
+export async function getSelectedFolderCount(
+  uris: vscode.Uri[],
+  options: Partial<ProcessingConfig> = {}
+): Promise<{ folderCount: number; fileUris: vscode.Uri[] }> {
+  if (uris.length === 0) {
+    vscode.window.showWarningMessage('No files or folders are selected to process.')
+    return { folderCount: 0, fileUris: [] }
+  }
+
+  const config = getProcessingConfig(options)
+
+  // Count folders and collect file URIs
+  let folderCount = 0
+  const processedFolderPaths = new Set<string>()
+
+  // Count initial folders
+  for (const uri of uris) {
+    const stat = await vscode.workspace.fs.stat(uri)
+    if (stat.type === vscode.FileType.Directory) {
+      folderCount++
+      processedFolderPaths.add(uri.fsPath)
+    }
+  }
+
+  // Track subfolders during collection if recursive
+  const trackFolderCallback = (folderPath: string) => {
+    if (!processedFolderPaths.has(folderPath)) {
+      folderCount++
+      processedFolderPaths.add(folderPath)
+    }
+  }
+
+  const fileUris = await collectFileUrisWithFolderTracking(
+    uris,
+    {
+      recursive: config.recursive,
+      excludedFileTypes: config.excludedFileTypes,
+      excludedFolders: config.excludedFolders
+    },
+    trackFolderCallback
+  )
+
+  const fileCount = fileUris.length
+  const shouldProceed = await validateFileCount(fileCount, config.fileThreshold)
+  if (!shouldProceed) {
+    return { folderCount: 0, fileUris: [] }
+  }
+
+  return { folderCount, fileUris }
+}
+
+/**
+ * Collects file URIs while tracking folder paths
+ */
+async function collectFileUrisWithFolderTracking(
+  uris: vscode.Uri[],
+  options: { recursive: boolean; excludedFileTypes: string[]; excludedFolders: string[] },
+  folderCallback: (folderPath: string) => void
+): Promise<vscode.Uri[]> {
+  const fileUris: vscode.Uri[] = []
+
+  for (const uri of uris) {
+    const stat = await vscode.workspace.fs.stat(uri)
+    if (stat.type === vscode.FileType.File) {
+      const name = path.basename(uri.fsPath)
+      if (!isFileTypeExcluded(name, options.excludedFileTypes)) {
+        fileUris.push(uri)
+      }
+    } else if (stat.type === vscode.FileType.Directory) {
+      const dirFileUris = await collectFileUrisFromDirectoryWithTracking(
+        uri,
+        options,
+        folderCallback
+      )
+      fileUris.push(...dirFileUris)
+    }
+  }
+
+  return fileUris
+}
+
+/**
+ * Collects file URIs from a directory while tracking subfolder paths
+ */
+async function collectFileUrisFromDirectoryWithTracking(
+  dirUri: vscode.Uri,
+  options: { recursive: boolean; excludedFileTypes: string[]; excludedFolders: string[] },
+  folderCallback: (folderPath: string) => void
+): Promise<vscode.Uri[]> {
+  const fileUris: vscode.Uri[] = []
+  const entries = await vscode.workspace.fs.readDirectory(dirUri)
+
+  for (const [name, type] of entries) {
+    const entryUri = vscode.Uri.joinPath(dirUri, name)
+
+    if (type === vscode.FileType.File) {
+      if (!isFileTypeExcluded(name, options.excludedFileTypes)) {
+        fileUris.push(entryUri)
+      }
+    } else if (type === vscode.FileType.Directory && options.recursive) {
+      if (!isFolderNameExcluded(name, options.excludedFolders)) {
+        // Track this subfolder
+        folderCallback(entryUri.fsPath)
+
+        // Process its contents
+        const subFileUris = await collectFileUrisFromDirectoryWithTracking(
+          entryUri,
+          options,
+          folderCallback
+        )
+        fileUris.push(...subFileUris)
+      }
+    }
+  }
+
+  return fileUris
+}
diff --git a/src/services/__tests__/telemetry.service.test.ts b/src/services/__tests__/telemetry.service.test.ts
@@ -1,10 +1,14 @@
 import * as assert from 'assert'
+import * as posthogModule from 'posthog-node'
 import * as sinon from 'sinon'
 import * as vscode from 'vscode'
+import { TELEMETRY_EVENTS } from '../../constants/telemetry'
 import { TelemetryService } from '../telemetry.service'
 
 suite('TelemetryService Tests', () => {
   let sandbox: sinon.SinonSandbox
+  let posthogCaptureStub: sinon.SinonStub
+  let telemetryServiceInstance: TelemetryService
 
   setup(() => {
     sandbox = sinon.createSandbox()
@@ -16,8 +20,31 @@ suite('TelemetryService Tests', () => {
       get: configGetStub
     } as any)
 
-    // Stub console.log to avoid test output pollution
+    // Stub console methods to avoid test output pollution
     sandbox.stub(console, 'log')
+    sandbox.stub(console, 'error')
+
+    // Create a fresh instance and clear any existing ones
+    // @ts-ignore: Accessing private static instance
+    TelemetryService.instance = undefined
+
+    // Set up PostHog stub
+    posthogCaptureStub = sandbox.stub()
+    const posthogStub = {
+      capture: posthogCaptureStub
+    }
+
+    // Stub the PostHog constructor
+    sandbox.stub(posthogModule, 'PostHog').returns(posthogStub as any)
+
+    // Get the instance after stubbing
+    telemetryServiceInstance = TelemetryService.getInstance()
+
+    // Set the service as ready and enabled
+    // @ts-ignore: Accessing private properties
+    telemetryServiceInstance.ready = true
+    // @ts-ignore: Accessing private properties
+    telemetryServiceInstance.enabled = true
   })
 
   teardown(() => {
@@ -32,16 +59,96 @@ suite('TelemetryService Tests', () => {
   })
 
   test('isEnabled should return the boolean state', () => {
-    const telemetryService = TelemetryService.getInstance()
-    const result = telemetryService.isEnabled()
+    const result = telemetryServiceInstance.isEnabled()
 
     // Just check that it returns a boolean value, as the actual
     // implementation details might change
     assert.strictEqual(typeof result, 'boolean')
   })
 
   test('isReady should return ready state', () => {
-    const telemetryService = TelemetryService.getInstance()
-    assert.strictEqual(typeof telemetryService.isReady(), 'boolean')
+    assert.strictEqual(typeof telemetryServiceInstance.isReady(), 'boolean')
+  })
+
+  test('trackEvent should track file count and folder count for ADD_FILE event', () => {
+    // Track event with file count and folder count
+    telemetryServiceInstance.trackEvent(TELEMETRY_EVENTS.FILES.ADD_FILE, {
+      fileCount: 5,
+      folderCount: 1
+    })
+
+    // Verify capture was called with correct parameters
+    sinon.assert.calledOnce(posthogCaptureStub)
+    const captureCall = posthogCaptureStub.getCall(0).args[0]
+
+    assert.strictEqual(captureCall.event, TELEMETRY_EVENTS.FILES.ADD_FILE)
+    assert.strictEqual(captureCall.properties.fileCount, 5)
+    assert.strictEqual(captureCall.properties.folderCount, 1)
+  })
+
+  test('trackEvent should track file count and folder count for ADD_FOLDER event', () => {
+    // Track event with file count, folder count, and recursive flag
+    telemetryServiceInstance.trackEvent(TELEMETRY_EVENTS.FILES.ADD_FOLDER, {
+      fileCount: 10,
+      folderCount: 3,
+      recursive: true
+    })
+
+    // Verify capture was called with correct parameters
+    sinon.assert.calledOnce(posthogCaptureStub)
+    const captureCall = posthogCaptureStub.getCall(0).args[0]
+
+    assert.strictEqual(captureCall.event, TELEMETRY_EVENTS.FILES.ADD_FOLDER)
+    assert.strictEqual(captureCall.properties.fileCount, 10)
+    assert.strictEqual(captureCall.properties.folderCount, 3)
+    assert.strictEqual(captureCall.properties.recursive, true)
+  })
+
+  test('trackEvent should track file count and folder count for ADD_SELECTION event', () => {
+    // Track event with file count, folder count, and recursive flag
+    telemetryServiceInstance.trackEvent(TELEMETRY_EVENTS.FILES.ADD_SELECTION, {
+      fileCount: 7,
+      folderCount: 2,
+      recursive: false
+    })
+
+    // Verify capture was called with correct parameters
+    sinon.assert.calledOnce(posthogCaptureStub)
+    const captureCall = posthogCaptureStub.getCall(0).args[0]
+
+    assert.strictEqual(captureCall.event, TELEMETRY_EVENTS.FILES.ADD_SELECTION)
+    assert.strictEqual(captureCall.properties.fileCount, 7)
+    assert.strictEqual(captureCall.properties.folderCount, 2)
+    assert.strictEqual(captureCall.properties.recursive, false)
+  })
+
+  test('trackEvent should track file count and folder count for ADD_SMART_SELECTION event', () => {
+    // Track event with file count and folder count
+    telemetryServiceInstance.trackEvent(TELEMETRY_EVENTS.FILES.ADD_SMART_SELECTION, {
+      fileCount: 15,
+      folderCount: 4
+    })
+
+    // Verify capture was called with correct parameters
+    sinon.assert.calledOnce(posthogCaptureStub)
+    const captureCall = posthogCaptureStub.getCall(0).args[0]
+
+    assert.strictEqual(captureCall.event, TELEMETRY_EVENTS.FILES.ADD_SMART_SELECTION)
+    assert.strictEqual(captureCall.properties.fileCount, 15)
+    assert.strictEqual(captureCall.properties.folderCount, 4)
+  })
+
+  test('trackEvent should not capture when telemetry is disabled', () => {
+    // Mock isEnabled to return false by setting the private enabled field
+    // @ts-ignore: Accessing private properties
+    telemetryServiceInstance.enabled = false
+
+    telemetryServiceInstance.trackEvent(TELEMETRY_EVENTS.FILES.ADD_FILE, {
+      fileCount: 5,
+      folderCount: 1
+    })
+
+    // Verify capture was not called
+    sinon.assert.notCalled(posthogCaptureStub)
   })
 })
