Include logs when reporting an issue

Author: dibarbet

SUPPORT.md

@@ -40,10 +40,11 @@ The template has a section to include the `C#` output window logs. These logs ar
 
 ##### C# LSP Trace Logs
 - To capture detailed requests sent to the Roslyn language server:
-  1. Set the `C#` output window log level to `Trace` (as described above).
-  2. Open the `C# LSP Trace Logs` output window.
+  1. Open the `C# LSP Trace Logs` output window.
+  2. Set the output window log level to `Trace`.
   3. Reproduce the issue.
   4. Copy the contents of the `C# LSP Trace Logs` output window.
+  5.  After collecting the logs, reset the log level to `Info`.
 
 
 ##### Other Ways to Set the Log Level

package.json

@@ -5627,6 +5627,11 @@
           "when": "editorLangId == csharp && (dotnet.server.activationContext == 'Roslyn' || dotnet.server.activationContext == 'OmniSharp')",
           "group": "2_dotnet@2"
         }
+      ],
+      "issue/reporter": [
+        {
+          "command": "csharp.reportIssue"
+        }
       ]
     },
     "viewsWelcome": [

src/lsptoolshost/activate.ts

@@ -83,7 +83,7 @@ export async function activateRoslynLanguageServer(
     registerCopilotContextProviders(context, languageServer, _channel);
 
     // Register any commands that need to be handled by the extension.
-    registerCommands(context, languageServer, hostExecutableResolver, _channel);
+    registerCommands(context, languageServer, hostExecutableResolver, _channel, _traceChannel);
     registerNestedCodeActionCommands(context, languageServer, _channel);
     registerCodeActionFixAllCommands(context, languageServer, _channel);
 

src/lsptoolshost/commands.ts

@@ -15,9 +15,10 @@ export function registerCommands(
     context: vscode.ExtensionContext,
     languageServer: RoslynLanguageServer,
     hostExecutableResolver: IHostExecutableResolver,
-    outputChannel: vscode.LogOutputChannel
+    outputChannel: vscode.LogOutputChannel,
+    csharpTraceChannel: vscode.LogOutputChannel
 ) {
-    registerExtensionCommands(context, languageServer, hostExecutableResolver, outputChannel);
+    registerExtensionCommands(context, hostExecutableResolver, outputChannel, csharpTraceChannel);
     registerWorkspaceCommands(context, languageServer);
     registerServerCommands(context, languageServer, outputChannel);
 }
@@ -27,16 +28,17 @@ export function registerCommands(
  */
 function registerExtensionCommands(
     context: vscode.ExtensionContext,
-    languageServer: RoslynLanguageServer,
     hostExecutableResolver: IHostExecutableResolver,
-    outputChannel: vscode.LogOutputChannel
+    outputChannel: vscode.LogOutputChannel,
+    csharpTraceChannel: vscode.LogOutputChannel
 ) {
     context.subscriptions.push(
         vscode.commands.registerCommand('csharp.reportIssue', async () =>
             reportIssue(
-                context.extension.packageJSON.version,
+                context,
                 getDotnetInfo,
                 /*shouldIncludeMonoInfo:*/ false,
+                [outputChannel, csharpTraceChannel],
                 hostExecutableResolver
             )
         )

src/omnisharp/features/commands.ts

@@ -35,7 +35,8 @@ export default function registerCommands(
     eventStream: EventStream,
     monoResolver: IHostExecutableResolver,
     dotnetResolver: IHostExecutableResolver,
-    workspaceInformationProvider: IWorkspaceDebugInformationProvider
+    workspaceInformationProvider: IWorkspaceDebugInformationProvider,
+    outputChannel: vscode.OutputChannel
 ): CompositeDisposable {
     const disposable = new CompositeDisposable();
     disposable.add(vscode.commands.registerCommand('o.restart', async () => restartOmniSharp(context, server)));
@@ -66,20 +67,31 @@ export default function registerCommands(
     );
 
     disposable.add(
-        vscode.commands.registerCommand('csharp.reportIssue', async () =>
-            reportIssue(
-                context.extension.packageJSON.version,
+        vscode.commands.registerCommand('csharp.reportIssue', async () => {
+            const logOutputChannel = isLogOutputChannel(outputChannel);
+            return reportIssue(
+                context,
                 getDotnetInfo,
                 platformInfo.isValidPlatformForMono(),
+                logOutputChannel ? [logOutputChannel] : [],
                 dotnetResolver,
                 monoResolver
-            )
-        )
+            );
+        })
     );
 
     return new CompositeDisposable(disposable);
 }
 
+function isLogOutputChannel(channel: vscode.OutputChannel): vscode.LogOutputChannel | undefined {
+    const anyChannel = channel as any;
+    if (anyChannel.logLevel) {
+        return channel as vscode.LogOutputChannel;
+    } else {
+        return undefined;
+    }
+}
+
 async function restartOmniSharp(context: vscode.ExtensionContext, server: OmniSharpServer) {
     if (server.isRunning()) {
         await server.restart();

src/omnisharp/omnisharpLanguageServer.ts

@@ -240,7 +240,8 @@ async function activate(
             eventStream,
             omnisharpMonoResolver,
             omnisharpDotnetResolver,
-            workspaceInformationProvider
+            workspaceInformationProvider,
+            outputChannel
         )
     );
 

src/shared/reportIssue.ts

@@ -11,14 +11,15 @@ import { CSharpExtensionId } from '../constants/csharpExtensionId';
 import { commonOptions, LanguageServerOptions, languageServerOptions } from './options';
 
 export default async function reportIssue(
-    csharpExtVersion: string,
+    context: vscode.ExtensionContext,
     getDotnetInfo: (dotNetCliPaths: string[]) => Promise<DotnetInfo>,
     shouldIncludeMonoInfo: boolean,
+    logChannels: vscode.LogOutputChannel[],
     dotnetResolver: IHostExecutableResolver,
     monoResolver?: IHostExecutableResolver
 ) {
     // Get info for the dotnet that the language server executable is run on, not the dotnet the language server will execute user code on.
-    let fullDotnetInfo: string | undefined;
+    let fullDotnetInfo = '';
     try {
         const info = await dotnetResolver.getHostExecutableInfo();
         const dotnetInfo = await getDotnetInfo([dirname(info.path)]);
@@ -33,10 +34,11 @@ export default async function reportIssue(
         monoInfo = await getMonoIfPlatformValid(monoResolver);
     }
 
-    const extensions = getInstalledExtensions();
-
+    const csharpExtVersion = context.extension.packageJSON.version;
     const useOmnisharp = commonOptions.useOmnisharpServer;
-    const logInfo = getLogInfo(useOmnisharp);
+    const extensionsTable = generateExtensionTable();
+    const optionsTable = generateOptionsTable();
+    const logInfo = await getLogInfo(logChannels, context);
 
     const body = `## Issue Description ##
 ## Steps to Reproduce ##
@@ -45,12 +47,13 @@ export default async function reportIssue(
 
 ## Actual Behavior ##
 
-## Logs ##
+`;
 
-${logInfo}
+    const userData = `### Logs ###
 
-## Environment information ##
+${logInfo}
 
+## Environment Information ##
 **VSCode version**: ${vscode.version}
 **C# Extension**: ${csharpExtVersion}
 **Using OmniSharp**: ${useOmnisharp}
@@ -59,16 +62,16 @@ ${monoInfo}
 <details><summary>Dotnet Information</summary>
 ${fullDotnetInfo}</details>
 <details><summary>Visual Studio Code Extensions</summary>
-${generateExtensionTable(extensions)}
+${extensionsTable}
 </details>
 <details><summary>C# Settings</summary>
-${generateOptionsTable()}
+${optionsTable}
 </details>
 `;
-
     await vscode.commands.executeCommand('workbench.action.openIssueReporter', {
         extensionId: CSharpExtensionId,
         issueBody: body,
+        data: userData,
     });
 }
 
@@ -82,7 +85,8 @@ function sortExtensions(a: vscode.Extension<any>, b: vscode.Extension<any>): num
     return 0;
 }
 
-function generateExtensionTable(extensions: vscode.Extension<any>[]) {
+function generateExtensionTable() {
+    const extensions = getInstalledExtensions();
     if (extensions.length <= 0) {
         return 'none';
     }
@@ -142,25 +146,47 @@ async function getMonoIfPlatformValid(monoResolver: IHostExecutableResolver): Pr
     ${monoVersion}</details>`;
 }
 
-function getLogInfo(useOmnisharp: boolean): string {
-    if (useOmnisharp) {
-        return `### OmniSharp log ###
-<details>Post the output from Output-->OmniSharp log here</details>
-        
-### C# log ###
-<details>Post the output from Output-->C# here</details>`;
-    } else {
-        return `<!--
+async function getLogInfo(logChannels: vscode.LogOutputChannel[], context: vscode.ExtensionContext): Promise<string> {
+    let logInfo = `<!--
 If you can, it would be the most helpful to zip up and attach the entire extensions log folder.  The folder can be opened by running the \`workbench.action.openExtensionLogsFolder\` command.
 
-Additionally, if you can reproduce the issue reliably, set the \`C#\` output window log level to 'Trace' re-run the scenario to get more detailed logs.
+Additionally, if you can reproduce the issue reliably, use trace logging, see https://github.com/dotnet/vscode-csharp/blob/main/SUPPORT.md#c-lsp-trace-logs and then report the issue.
 -->
-        
-### C# log ###
-<details>Post the output from Output-->C# here</details>
+`;
 
-### C# LSP Trace Logs ###
-<details>Post the output from Output-->C# LSP Trace Logs here.  Requires the \`C#\` output window log level to be set to \`Trace\`</details>`;
+    for (const channel of logChannels) {
+        const contents = await getLogOutputChannelContents(context, channel);
+        logInfo += `### ${channel.name} log ###
+<details>
+
+\`\`\`
+${contents}
+\`\`\`
+</details>
+
+`;
+    }
+
+    return logInfo;
+}
+
+async function getLogOutputChannelContents(
+    context: vscode.ExtensionContext,
+    channel: vscode.LogOutputChannel
+): Promise<string> {
+    const logFilePath = vscode.Uri.joinPath(context.logUri, channel.name + '.log');
+
+    try {
+        const fileStat = await vscode.workspace.fs.stat(logFilePath);
+        if (fileStat.type !== vscode.FileType.File) {
+            return `Unable to find log file at ${logFilePath}, ${fileStat.type}`;
+        }
+
+        const logContent = await vscode.workspace.fs.readFile(logFilePath);
+        const contents = Buffer.from(logContent).toString('utf8');
+        return contents;
+    } catch (error) {
+        return `Error reading log file: ${error instanceof Error ? error.message : `${error}`}`;
     }
 }
 

test/omnisharp/omnisharpUnitTests/features/reportIssue.test.ts

@@ -36,6 +36,14 @@ describe(`${reportIssue.name}`, () => {
         extensionPath: 'c:/extensions/xyz-x64',
     } as vscode.Extension<any>;
 
+    const context = {
+        extension: {
+            packageJSON: {
+                version: csharpExtVersion,
+            },
+        },
+    } as vscode.ExtensionContext;
+
     const fakeDotnetInfo: DotnetInfo = {
         FullInfo: 'myDotnetInfo',
         Version: '1.0.x',
@@ -59,7 +67,7 @@ describe(`${reportIssue.name}`, () => {
         } as vscode.WorkspaceConfiguration);
 
         jest.spyOn(vscode.commands, 'executeCommand').mockImplementation(async (command: string, ...rest: any[]) => {
-            issueBody = rest[0].issueBody;
+            issueBody = rest[0].issueBody + rest[0].data;
             return {} as any;
         });
         jest.replaceProperty(vscode.extensions, 'all', [extension1, extension2] as readonly vscode.Extension<any>[]);
@@ -70,38 +78,38 @@ describe(`${reportIssue.name}`, () => {
 
     describe('The body is passed to the vscode clipboard and', () => {
         test('it contains the vscode version', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(issueBody).toContain(`**VSCode version**: ${vscodeVersion}`);
         });
 
         test('it contains the csharp extension version', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(issueBody).toContain(`**C# Extension**: ${csharpExtVersion}`);
         });
 
         test('it contains dotnet info', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(issueBody).toContain(fakeDotnetInfo.FullInfo);
         });
 
         test('mono information is obtained when it is a valid mono platform', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(fakeMonoResolver.getMonoCalled).toEqual(true);
         });
 
         test('mono version is put in the body when it is a valid mono platform', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(fakeMonoResolver.getMonoCalled).toEqual(true);
             expect(issueBody).toContain(fakeMonoInfo.version);
         });
 
         test('mono information is not obtained when it is not a valid mono platform', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, false, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, false, [], fakeDotnetResolver, fakeMonoResolver);
             expect(fakeMonoResolver.getMonoCalled).toEqual(false);
         });
 
         test('The url contains the name, publisher and version for all the extensions that are not builtin', async () => {
-            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            await reportIssue(context, getDotnetInfo, isValidForMono, [], fakeDotnetResolver, fakeMonoResolver);
             expect(issueBody).toContain(extension2.packageJSON.name);
             expect(issueBody).toContain(extension2.packageJSON.publisher);
             expect(issueBody).toContain(extension2.packageJSON.version);