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

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

@@ -33,6 +33,7 @@ import {
 import { Writable } from 'stream'
 import { CodeWhispererSettings } from '../../codewhisperer/util/codewhispererSettings'
 import { ResourcePaths, fs, getLogger, globals } from '../../shared'
+import { telemetry } from '../../shared/telemetry'
 
 const localize = nls.loadMessageBundle()
 
@@ -173,104 +174,108 @@ export class LspClient {
  * This function assumes the LSP server has already been downloaded.
  */
 export async function activate(extensionContext: ExtensionContext, resourcePaths: ResourcePaths) {
-    LspClient.instance
-    const toDispose = extensionContext.subscriptions
+    return await telemetry.lsp_setup.run(async (span) => {
+        span.record({ lspSetupStage: 'activate' })
+        const startTime = performance.now()
+        LspClient.instance
+        const toDispose = extensionContext.subscriptions
 
-    let rangeFormatting: Disposable | undefined
-    // The debug options for the server
-    // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging
-    const debugOptions = { execArgv: ['--nolazy', '--preserve-symlinks', '--stdio'] }
+        let rangeFormatting: Disposable | undefined
+        // The debug options for the server
+        // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging
+        const debugOptions = { execArgv: ['--nolazy', '--preserve-symlinks', '--stdio'] }
 
-    const workerThreads = CodeWhispererSettings.instance.getIndexWorkerThreads()
-    const gpu = CodeWhispererSettings.instance.isLocalIndexGPUEnabled()
+        const workerThreads = CodeWhispererSettings.instance.getIndexWorkerThreads()
+        const gpu = CodeWhispererSettings.instance.isLocalIndexGPUEnabled()
 
-    if (gpu) {
-        process.env.Q_ENABLE_GPU = 'true'
-    } else {
-        delete process.env.Q_ENABLE_GPU
-    }
-    if (workerThreads > 0 && workerThreads < 100) {
-        process.env.Q_WORKER_THREADS = workerThreads.toString()
-    } else {
-        delete process.env.Q_WORKER_THREADS
-    }
+        if (gpu) {
+            process.env.Q_ENABLE_GPU = 'true'
+        } else {
+            delete process.env.Q_ENABLE_GPU
+        }
+        if (workerThreads > 0 && workerThreads < 100) {
+            process.env.Q_WORKER_THREADS = workerThreads.toString()
+        } else {
+            delete process.env.Q_WORKER_THREADS
+        }
 
-    const serverModule = resourcePaths.lsp
+        const serverModule = resourcePaths.lsp
 
-    const child = spawn(resourcePaths.node, [serverModule, ...debugOptions.execArgv])
-    // share an encryption key using stdin
-    // follow same practice of DEXP LSP server
-    writeEncryptionInit(child.stdin)
+        const child = spawn(resourcePaths.node, [serverModule, ...debugOptions.execArgv])
+        // share an encryption key using stdin
+        // follow same practice of DEXP LSP server
+        writeEncryptionInit(child.stdin)
 
-    // If the extension is launch in debug mode the debug server options are use
-    // Otherwise the run options are used
-    let serverOptions: ServerOptions = {
-        run: { module: serverModule, transport: TransportKind.ipc },
-        debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions },
-    }
+        // If the extension is launch in debug mode the debug server options are use
+        // Otherwise the run options are used
+        let serverOptions: ServerOptions = {
+            run: { module: serverModule, transport: TransportKind.ipc },
+            debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions },
+        }
 
-    serverOptions = () => Promise.resolve(child!)
+        serverOptions = () => Promise.resolve(child!)
 
-    const documentSelector = [{ scheme: 'file', language: '*' }]
+        const documentSelector = [{ scheme: 'file', language: '*' }]
 
-    // Options to control the language client
-    const clientOptions: LanguageClientOptions = {
-        // Register the server for json documents
-        documentSelector,
-        initializationOptions: {
-            handledSchemaProtocols: ['file', 'untitled'], // language server only loads file-URI. Fetching schemas with other protocols ('http'...) are made on the client.
-            provideFormatter: false, // tell the server to not provide formatting capability and ignore the `aws.stepfunctions.asl.format.enable` setting.
-            // this is used by LSP to determine index cache path, move to this folder so that when extension updates index is not deleted.
-            extensionPath: path.join(fs.getUserHomeDir(), '.aws', 'amazonq', 'cache'),
-        },
-        // Log to the Amazon Q Logs so everything is in a single channel
-        // TODO: Add prefix to the language server logs so it is easier to search
-        outputChannel: globals.logOutputChannel,
-    }
+        // Options to control the language client
+        const clientOptions: LanguageClientOptions = {
+            // Register the server for json documents
+            documentSelector,
+            initializationOptions: {
+                handledSchemaProtocols: ['file', 'untitled'], // language server only loads file-URI. Fetching schemas with other protocols ('http'...) are made on the client.
+                provideFormatter: false, // tell the server to not provide formatting capability and ignore the `aws.stepfunctions.asl.format.enable` setting.
+                // this is used by LSP to determine index cache path, move to this folder so that when extension updates index is not deleted.
+                extensionPath: path.join(fs.getUserHomeDir(), '.aws', 'amazonq', 'cache'),
+            },
+            // Log to the Amazon Q Logs so everything is in a single channel
+            // TODO: Add prefix to the language server logs so it is easier to search
+            outputChannel: globals.logOutputChannel,
+        }
 
-    // Create the language client and start the client.
-    LspClient.instance.client = new LanguageClient(
-        'amazonq',
-        localize('amazonq.server.name', 'Amazon Q Language Server'),
-        serverOptions,
-        clientOptions
-    )
-    LspClient.instance.client.registerProposedFeatures()
+        // Create the language client and start the client.
+        LspClient.instance.client = new LanguageClient(
+            'amazonq',
+            localize('amazonq.server.name', 'Amazon Q Language Server'),
+            serverOptions,
+            clientOptions
+        )
+        LspClient.instance.client.registerProposedFeatures()
 
-    const disposable = LspClient.instance.client.start()
-    toDispose.push(disposable)
+        const disposable = LspClient.instance.client.start()
+        toDispose.push(disposable)
 
-    let savedDocument: vscode.Uri | undefined = undefined
+        let savedDocument: vscode.Uri | undefined = undefined
 
-    toDispose.push(
-        vscode.workspace.onDidSaveTextDocument((document) => {
-            if (document.uri.scheme !== 'file') {
-                return
-            }
-            savedDocument = document.uri
-        }),
-        vscode.window.onDidChangeActiveTextEditor((editor) => {
-            if (savedDocument && editor && editor.document.uri.fsPath !== savedDocument.fsPath) {
-                void LspClient.instance.updateIndex([savedDocument.fsPath], 'update')
-            }
-        }),
-        vscode.workspace.onDidCreateFiles((e) => {
-            void LspClient.instance.updateIndex(
-                e.files.map((f) => f.fsPath),
-                'add'
-            )
-        }),
-        vscode.workspace.onDidDeleteFiles((e) => {
-            void LspClient.instance.updateIndex(
-                e.files.map((f) => f.fsPath),
-                'remove'
-            )
+        toDispose.push(
+            vscode.workspace.onDidSaveTextDocument((document) => {
+                if (document.uri.scheme !== 'file') {
+                    return
+                }
+                savedDocument = document.uri
+            }),
+            vscode.window.onDidChangeActiveTextEditor((editor) => {
+                if (savedDocument && editor && editor.document.uri.fsPath !== savedDocument.fsPath) {
+                    void LspClient.instance.updateIndex([savedDocument.fsPath], 'update')
+                }
+            }),
+            vscode.workspace.onDidCreateFiles((e) => {
+                void LspClient.instance.updateIndex(
+                    e.files.map((f) => f.fsPath),
+                    'add'
+                )
+            }),
+            vscode.workspace.onDidDeleteFiles((e) => {
+                void LspClient.instance.updateIndex(
+                    e.files.map((f) => f.fsPath),
+                    'remove'
+                )
+            })
+        )
+        void LspClient.instance.client.onReady().then(() => {
+            const disposableFunc = { dispose: () => rangeFormatting?.dispose() as void }
+            toDispose.push(disposableFunc)
         })
-    )
-
-    return LspClient.instance.client.onReady().then(() => {
-        const disposableFunc = { dispose: () => rangeFormatting?.dispose() as void }
-        toDispose.push(disposableFunc)
+        span.record({ duration: performance.now() - startTime })
     })
 }
 

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

@@ -160,9 +160,14 @@ export class LspController {
         }
         setImmediate(async () => {
             try {
-                const installResult = await new WorkspaceLSPResolver().resolve()
-                await activateLsp(context, installResult.resourcePaths)
-                getLogger().info('LspController: LSP activated')
+                await telemetry.lsp_setup.run(async (span) => {
+                    const startTime = performance.now()
+                    span.record({ lspSetupStage: 'final' })
+                    const installResult = await new WorkspaceLSPResolver().resolve()
+                    await activateLsp(context, installResult.resourcePaths)
+                    getLogger().info('LspController: LSP activated')
+                    span.record({ duration: performance.now() - startTime })
+                })
                 void LspController.instance.buildIndex(buildIndexConfig)
                 // log the LSP server CPU and Memory usage per 30 minutes.
                 globals.clock.setInterval(

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

@@ -10,6 +10,7 @@ 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'
 
 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 +19,31 @@ 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 telemetry.lsp_setup.run(async (span) => {
+            const startTime = performance.now()
+            span.record({ lspSetupStage: 'fetchManifest' })
+            const result = await new ManifestResolver(manifestUrl, name).resolve()
+            span.record({
+                lspSetupLocation: result.location ?? 'unknown',
+                duration: performance.now() - startTime,
+            })
+            return result
+        })
+
+        const installationResult = await telemetry.lsp_setup.run(async (span) => {
+            const startTime = performance.now()
+            span.record({ lspSetupStage: 'serverCall' })
+            const result = await new LanguageServerResolver(
+                manifest,
+                name,
+                new Range(supportedLspServerVersions)
+            ).resolve()
+            span.record({
+                lspSetupLocation: result.location ?? 'unknown',
+                duration: performance.now() - startTime,
+            })
+            return result
+        })
 
         const nodeName =
             process.platform === 'win32' ? getNodeExecutableName() : `node-${process.platform}-${process.arch}`

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,17 @@
 {
     "types": [
+        {
+            "name": "lspSetupStage",
+            "type": "string",
+            "allowedValues": ["fetchManifest", "serverCall", "validate", "activate", "final"],
+            "description": "The stage of the LSP setup process"
+        },
+        {
+            "name": "lspSetupLocation",
+            "type": "string",
+            "allowedValues": ["cache", "remote", "fallback", "override", "unknown"],
+            "description": "The location of the LSP server"
+        },
         {
             "name": "amazonGenerateApproachLatency",
             "type": "double",
@@ -358,6 +370,28 @@
         }
     ],
     "metrics": [
+        {
+            "name": "lsp_setup",
+            "description": "LSP setup event",
+            "metadata": [
+                {
+                    "type": "lspSetupStage",
+                    "required": true
+                },
+                {
+                    "type": "lspSetupLocation",
+                    "required": false
+                },
+                {
+                    "type": "duration",
+                    "required": true
+                },
+                {
+                    "type": "result",
+                    "required": true
+                }
+            ]
+        },
         {
             "name": "ide_fileSystem",
             "description": "File System event on execution",