telemetry(lsp): Integrate language server/manifest resolver telemetry

packages/core/src/amazonq/lsp/lspController.ts

@@ -15,6 +15,7 @@ import { isCloud9 } from '../../shared/extensionUtilities'
 import globals, { isWeb } from '../../shared/extensionGlobals'
 import { isAmazonInternalOs } from '../../shared/vscode/env'
 import { WorkspaceLSPResolver } from './workspaceInstaller'
+import { lspSetupStage } from './util'
 
 export interface Chunk {
     readonly filePath: string
@@ -160,9 +161,11 @@ export class LspController {
         }
         setImmediate(async () => {
             try {
-                const installResult = await new WorkspaceLSPResolver().resolve()
-                await activateLsp(context, installResult.resourcePaths)
-                getLogger().info('LspController: LSP activated')
+                await lspSetupStage('final', async () => {
+                    const installResult = await new WorkspaceLSPResolver().resolve()
+                    await lspSetupStage('launch', async () => activateLsp(context, installResult.resourcePaths))
+                    getLogger().info('LspController: LSP activated')
+                })
                 void LspController.instance.buildIndex(buildIndexConfig)
                 // log the LSP server CPU and Memory usage per 30 minutes.
                 globals.clock.setInterval(

packages/core/src/amazonq/lsp/util.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { LanguageServerSetupStage, telemetry } from '../../shared/telemetry'
+
+export async function lspSetupStage<T>(stageName: LanguageServerSetupStage, stage: () => Promise<T>) {
+    return await telemetry.languageServer_setup.run(async (span) => {
+        const startTime = performance.now()
+        const result = await stage()
+        span.record({ languageServerSetupStage: stageName })
+        span.record({ duration: performance.now() - startTime })
+        return result
+    })
+}

packages/core/src/amazonq/lsp/workspaceInstaller.ts

@@ -10,6 +10,8 @@ import { LanguageServerResolver } from '../../shared/lsp/lspResolver'
 import { Range } from 'semver'
 import { getNodeExecutableName } from '../../shared/lsp/utils/platform'
 import { fs } from '../../shared/fs/fs'
+import { telemetry } from '../../shared/telemetry'
+import { lspSetupStage } from './util'
 
 const manifestUrl = 'https://aws-toolkit-language-servers.amazonaws.com/q-context/manifest.json'
 // this LSP client in Q extension is only going to work with these LSP server versions
@@ -18,12 +20,28 @@ const supportedLspServerVersions = '0.1.32'
 export class WorkspaceLSPResolver implements LspResolver {
     async resolve(): Promise<LspResolution> {
         const name = 'AmazonQ-Workspace'
-        const manifest = await new ManifestResolver(manifestUrl, name).resolve()
-        const installationResult = await new LanguageServerResolver(
-            manifest,
-            name,
-            new Range(supportedLspServerVersions)
-        ).resolve()
+        const manifest = await lspSetupStage('getManifest', async () => {
+            const result = await new ManifestResolver(manifestUrl, name).resolve()
+            telemetry.record({
+                manifestVersion: result.manifestSchemaVersion,
+                languageServerResourceLocation: result.location ?? 'unknown',
+            })
+            return result
+        })
+        telemetry.record({
+            manifestVersion: manifest.manifestSchemaVersion,
+        })
+        const installationResult = await lspSetupStage('getServer', async () => {
+            const result = await new LanguageServerResolver(
+                manifest,
+                name,
+                new Range(supportedLspServerVersions)
+            ).resolve()
+            telemetry.record({
+                languageServerResourceLocation: result.location ?? 'unknown',
+            })
+            return result
+        })
 
         const nodeName =
             process.platform === 'win32' ? getNodeExecutableName() : `node-${process.platform}-${process.arch}`

packages/core/src/shared/lsp/lspResolver.ts

@@ -13,6 +13,7 @@ import { TargetContent, logger, LspResult, LspVersion, Manifest } from './types'
 import { getApplicationSupportFolder } from '../vscode/env'
 import { createHash } from '../crypto'
 import request from '../request'
+import { lspSetupStage } from '../../amazonq/lsp/util'
 
 export class LanguageServerResolver {
     constructor(
@@ -164,26 +165,39 @@ export class LanguageServerResolver {
             await fs.mkdir(downloadDirectory)
         }
 
-        const downloadTasks = contents.map(async (content) => {
-            // TODO This should be using the retryable http library but it doesn't seem to support zips right now
-            const res = await request.fetch('GET', content.url).response
-            if (!res.ok || !res.body) {
-                return false
+        const fetchTasks = contents.map(async (content) => {
+            return {
+                res: await request.fetch('GET', content.url).response,
+                hash: content.hashes[0],
+                filename: content.filename,
+            }
+        })
+        const fetchResults = await Promise.all(fetchTasks)
+        const verifyTasks = fetchResults.flatMap(async (fetchResult) => {
+            if (!fetchResult.res.ok || !fetchResult.res.body) {
+                return []
             }
 
-            const arrBuffer = await res.arrayBuffer()
+            const arrBuffer = await fetchResult.res.arrayBuffer()
             const data = Buffer.from(arrBuffer)
 
             const hash = createHash('sha384', data)
-            if (hash === content.hashes[0]) {
-                await fs.writeFile(`${downloadDirectory}/${content.filename}`, data)
-                return true
+            if (hash === fetchResult.hash) {
+                return [{ filename: fetchResult.filename, data }]
             }
-            return false
+            return []
         })
-        const downloadResults = await Promise.all(downloadTasks)
-        const downloadResult = downloadResults.every(Boolean)
-        return downloadResult && this.extractZipFilesFromRemote(downloadDirectory)
+        const filesToDownload = await lspSetupStage('validate', async () => (await Promise.all(verifyTasks)).flat())
+
+        if (filesToDownload.length !== contents.length) {
+            return false
+        }
+
+        for (const file of filesToDownload) {
+            await fs.writeFile(`${downloadDirectory}/${file.filename}`, file.data)
+        }
+
+        return this.extractZipFilesFromRemote(downloadDirectory)
     }
 
     private async extractZipFilesFromRemote(downloadDirectory: string) {

packages/core/src/shared/lsp/manifestResolver.ts

@@ -55,7 +55,7 @@ export class ManifestResolver {
         const manifest = this.parseManifest(resp.content)
         await this.saveManifest(resp.eTag, resp.content)
         this.checkDeprecation(manifest)
-
+        manifest.location = 'remote'
         return manifest
     }
 
@@ -70,6 +70,7 @@ export class ManifestResolver {
 
         const manifest = this.parseManifest(manifestData.content)
         this.checkDeprecation(manifest)
+        manifest.location = 'cache'
         return manifest
     }
 

packages/core/src/shared/lsp/types.ts

@@ -53,6 +53,7 @@ export interface Manifest {
     artifactDescription: string
     isManifestDeprecated: boolean
     versions: LspVersion[]
+    location?: Location
 }
 
 export interface VersionRange {

packages/core/src/shared/telemetry/vscodeTelemetry.json

@@ -1,5 +1,22 @@
 {
     "types": [
+        {
+            "name": "languageServerSetupStage",
+            "type": "string",
+            "allowedValues": ["getManifest", "getServer", "validate", "launch", "final"],
+            "description": "The stage of the LSP setup process"
+        },
+        {
+            "name": "languageServerResourceLocation",
+            "type": "string",
+            "allowedValues": ["cache", "remote", "fallback", "override", "unknown"],
+            "description": "The location of the LSP resource"
+        },
+        {
+            "name": "manifestVersion",
+            "type": "string",
+            "description": "The version of the manifest file"
+        },
         {
             "name": "amazonGenerateApproachLatency",
             "type": "double",
@@ -358,6 +375,24 @@
         }
     ],
     "metrics": [
+        {
+            "name": "languageServer_setup",
+            "description": "LSP setup event",
+            "metadata": [
+                {
+                    "type": "languageServerSetupStage",
+                    "required": true
+                },
+                {
+                    "type": "languageServerResourceLocation",
+                    "required": false
+                },
+                {
+                    "type": "manifestVersion",
+                    "required": false
+                }
+            ]
+        },
         {
             "name": "ide_fileSystem",
             "description": "File System event on execution",