Log more info with the configuration provider telemetry (#12193)

Author: bobbrow

Extension/src/LanguageServer/client.ts

@@ -111,10 +111,6 @@ export function disposeWorkspaceData(): void {
     workspaceDisposables = [];
 }
 
-function logTelemetry(notificationBody: TelemetryPayload): void {
-    telemetry.logLanguageServerEvent(notificationBody.event, notificationBody.properties, notificationBody.metrics);
-}
-
 /** Note: We should not await on the following functions,
  * or any function that returns a promise acquired from them,
  * vscode.window.showInformationMessage, vscode.window.showWarningMessage, vscode.window.showErrorMessage
@@ -2000,13 +1996,17 @@ export class DefaultClient implements Client {
             onFinished();
             return;
         }
-        telemetry.logLanguageServerEvent('provideCustomConfiguration', { providerId });
-        void this.provideCustomConfigurationAsync(docUri, requestFile, replaceExisting, onFinished, provider);
+        try {
+            DefaultClient.isStarted.reset();
+            const result = await this.provideCustomConfigurationAsync(docUri, requestFile, replaceExisting, provider);
+            telemetry.logLanguageServerEvent('provideCustomConfiguration', { providerId, result });
+        } finally {
+            onFinished();
+            DefaultClient.isStarted.resolve();
+        }
     }
 
-    private async provideCustomConfigurationAsync(docUri: vscode.Uri, requestFile: string | undefined, replaceExisting: boolean | undefined, onFinished: () => void, provider: CustomConfigurationProvider1) {
-        DefaultClient.isStarted.reset();
-
+    private async provideCustomConfigurationAsync(docUri: vscode.Uri, requestFile: string | undefined, replaceExisting: boolean | undefined, provider: CustomConfigurationProvider1): Promise<string> {
         const tokenSource: vscode.CancellationTokenSource = new vscode.CancellationTokenSource();
 
         const params: QueryTranslationUnitSourceParams = {
@@ -2018,14 +2018,12 @@ export class DefaultClient implements Client {
         const response: QueryTranslationUnitSourceResult = await this.languageClient.sendRequest(QueryTranslationUnitSourceRequest, params);
         if (!response.candidates || response.candidates.length === 0) {
             // If we didn't receive any candidates, no configuration is needed.
-            onFinished();
-            DefaultClient.isStarted.resolve();
-            return;
+            return "noCandidates";
         }
 
         // Need to loop through candidates, to see if we can get a custom configuration from any of them.
         // Wrap all lookups in a single task, so we can apply a timeout to the entire duration.
-        const provideConfigurationAsync: () => Thenable<SourceFileConfigurationItem[] | null | undefined> = async () => {
+        const provideConfigurationAsync: () => Thenable<SourceFileConfigurationItem[] | undefined> = async () => {
             const uris: vscode.Uri[] = [];
             for (let i: number = 0; i < response.candidates.length; ++i) {
                 const candidate: string = response.candidates[i];
@@ -2085,44 +2083,41 @@ export class DefaultClient implements Client {
                 }
                 return configs as SourceFileConfigurationItem[];
             }
-            if (tokenSource.token.isCancellationRequested) {
-                return null;
-            }
+            return undefined;
         };
+        let result: string = "success";
         try {
-            const configs: SourceFileConfigurationItem[] | null | undefined = await this.callTaskWithTimeout(provideConfigurationAsync, configProviderTimeout, tokenSource);
+            const configs: SourceFileConfigurationItem[] | undefined = await this.callTaskWithTimeout(provideConfigurationAsync, configProviderTimeout, tokenSource);
             if (configs && configs.length > 0) {
                 this.sendCustomConfigurations(configs, provider.version);
+            } else {
+                result = "noConfigurations";
             }
-            onFinished();
         } catch (err) {
-            if (requestFile) {
-                onFinished();
-                return;
-            }
-            const settings: CppSettings = new CppSettings(this.RootUri);
-            if (settings.configurationWarnings && !this.isExternalHeader(docUri) && !vscode.debug.activeDebugSession) {
-                const dismiss: string = localize("dismiss.button", "Dismiss");
-                const disable: string = localize("disable.warnings.button", "Disable Warnings");
-                const configName: string | undefined = this.configuration.CurrentConfiguration?.name;
-                if (!configName) {
-                    return;
-                }
-                let message: string = localize("unable.to.provide.configuration",
-                    "{0} is unable to provide IntelliSense configuration information for '{1}'. Settings from the '{2}' configuration will be used instead.",
-                    provider.name, docUri.fsPath, configName);
-                if (err) {
-                    message += ` (${err})`;
-                }
+            result = "timeout";
+            if (!requestFile) {
+                const settings: CppSettings = new CppSettings(this.RootUri);
+                if (settings.configurationWarnings && !this.isExternalHeader(docUri) && !vscode.debug.activeDebugSession) {
+                    const dismiss: string = localize("dismiss.button", "Dismiss");
+                    const disable: string = localize("disable.warnings.button", "Disable Warnings");
+                    const configName: string | undefined = this.configuration.CurrentConfiguration?.name;
+                    if (!configName) {
+                        return "noConfigName";
+                    }
+                    let message: string = localize("unable.to.provide.configuration",
+                        "{0} is unable to provide IntelliSense configuration information for '{1}'. Settings from the '{2}' configuration will be used instead.",
+                        provider.name, docUri.fsPath, configName);
+                    if (err) {
+                        message += ` (${err})`;
+                    }
 
-                if (await vscode.window.showInformationMessage(message, dismiss, disable) === disable) {
-                    settings.toggleSetting("configurationWarnings", "enabled", "disabled");
+                    if (await vscode.window.showInformationMessage(message, dismiss, disable) === disable) {
+                        settings.toggleSetting("configurationWarnings", "enabled", "disabled");
+                    }
                 }
             }
-        } finally {
-            DefaultClient.isStarted.resolve();
         }
-
+        return result;
     }
 
     private async handleRequestCustomConfig(requestFile: string): Promise<void> {
@@ -2323,7 +2318,7 @@ export class DefaultClient implements Client {
 
         this.languageClient.onNotification(ReloadWindowNotification, () => void util.promptForReloadWindowDueToSettingsChange());
         this.languageClient.onNotification(UpdateTrustedCompilersNotification, (e) => void this.addTrustedCompiler(e.compilerPath));
-        this.languageClient.onNotification(LogTelemetryNotification, logTelemetry);
+        this.languageClient.onNotification(LogTelemetryNotification, (e) => this.logTelemetry(e));
         this.languageClient.onNotification(ReportStatusNotification, (e) => void this.updateStatus(e));
         this.languageClient.onNotification(ReportTagParseStatusNotification, (e) => this.updateTagParseStatus(e));
         this.languageClient.onNotification(CompileCommandsPathsNotification, (e) => void this.promptCompileCommands(e));
@@ -2562,6 +2557,13 @@ export class DefaultClient implements Client {
         }
     }
 
+    private logTelemetry(notificationBody: TelemetryPayload): void {
+        if (notificationBody.event === "includeSquiggles" && this.configurationProvider && notificationBody.properties) {
+            notificationBody.properties["providerId"] = this.configurationProvider;
+        }
+        telemetry.logLanguageServerEvent(notificationBody.event, notificationBody.properties, notificationBody.metrics);
+    }
+
     private async updateStatus(notificationBody: ReportStatusNotificationBody): Promise<void> {
         const message: string = notificationBody.status;
         util.setProgress(util.getProgressExecutableSuccess());