Add captureActivityLogs to CSharpExtensionExports

Co-authored-by: JoeRobich <611219+JoeRobich@users.noreply.github.com>

Author: Copilot

src/activateRoslyn.ts

@@ -12,7 +12,7 @@ import TelemetryReporter from '@vscode/extension-telemetry';
 import { RoslynLanguageServer } from './lsptoolshost/server/roslynLanguageServer';
 import { CSharpDevKitExports } from './csharpDevKitExports';
 import { RoslynLanguageServerEvents, ServerState } from './lsptoolshost/server/languageServerEvents';
-import { activateRoslynLanguageServer } from './lsptoolshost/activate';
+import { activateRoslynLanguageServer, createCaptureActivityLogs } from './lsptoolshost/activate';
 import Descriptors from './lsptoolshost/solutionSnapshot/descriptors';
 import { getBrokeredServiceContainer } from './lsptoolshost/serviceBroker/brokeredServicesHosting';
 import { debugSessionTracker } from './coreclrDebug/provisionalDebugSessionTracker';
@@ -86,6 +86,10 @@ export function activateRoslyn(
         getComponentFolder: (componentName) => {
             return getComponentFolder(componentName, languageServerOptions);
         },
+        captureActivityLogs: async () => {
+            const languageServer = await roslynLanguageServerStartedPromise;
+            return createCaptureActivityLogs(languageServer, razorLogger);
+        },
     };
 
     return exports;

src/csharpExtensionExports.ts

@@ -24,6 +24,10 @@ export interface OmnisharpExtensionExports {
     logDirectory: string;
 }
 
+export interface ActivityLogCapture extends vscode.Disposable {
+    getActivityLogs(): { csharpLog: string; lspTraceLog: string; razorLog: string };
+}
+
 export interface CSharpExtensionExports {
     isLimitedActivation: false;
     initializationFinished: () => Promise<void>;
@@ -32,6 +36,7 @@ export interface CSharpExtensionExports {
     determineBrowserType: () => Promise<string | undefined>;
     experimental: CSharpExtensionExperimentalExports;
     getComponentFolder: (componentName: string) => string;
+    captureActivityLogs: () => Promise<ActivityLogCapture>;
 }
 
 export interface CSharpExtensionExperimentalExports {

src/lsptoolshost/activate.ts

@@ -31,6 +31,8 @@ import { RazorLogger } from '../razor/src/razorLogger';
 import { registerRazorEndpoints } from './razor/razorEndpoints';
 import { ObservableLogOutputChannel } from './logging/observableLogOutputChannel';
 import { registerSourceGeneratorRefresh } from './generators/sourceGeneratorsRefresh';
+import { ActivityLogCapture } from '../csharpExtensionExports';
+import { RazorLogObserver } from './logging/loggingUtils';
 
 let _channel: ObservableLogOutputChannel;
 let _traceChannel: ObservableLogOutputChannel;
@@ -174,3 +176,36 @@ function getInstalledServerPath(platformInfo: PlatformInformation): string {
 
     return pathWithExtension;
 }
+
+/**
+ * Creates an activity log capture that collects logs from the C#, LSP trace, and Razor channels.
+ * Sets log levels to Trace for capture. Call dispose() to stop capturing and restore log levels.
+ */
+export async function createCaptureActivityLogs(
+    languageServer: RoslynLanguageServer,
+    razorLogger: RazorLogger
+): Promise<ActivityLogCapture> {
+    const csharpLogObserver = _channel.observe();
+    const traceLogObserver = _traceChannel.observe();
+    const razorLogObserver = new RazorLogObserver(razorLogger);
+
+    const restoreLogLevels = await languageServer.setLogLevelsForCapture();
+    razorLogger.traceEnabled = true;
+    razorLogger.debugEnabled = true;
+    razorLogger.infoEnabled = true;
+
+    return {
+        getActivityLogs: () => ({
+            csharpLog: csharpLogObserver.getLog(),
+            lspTraceLog: traceLogObserver.getLog(),
+            razorLog: razorLogObserver.getLog(),
+        }),
+        dispose: async () => {
+            csharpLogObserver.dispose();
+            traceLogObserver.dispose();
+            razorLogObserver.dispose();
+            await restoreLogLevels();
+            await razorLogger.updateLogLevelAsync();
+        },
+    };
+}

test/lsptoolshost/unitTests/captureActivityLogs.test.ts

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { describe, test, expect } from '@jest/globals';
+import { LogObserver } from '../../../src/lsptoolshost/logging/observableLogOutputChannel';
+import { RazorLogObserver } from '../../../src/lsptoolshost/logging/loggingUtils';
+
+describe('captureActivityLogs', () => {
+    describe('LogObserver', () => {
+        test('formatLogMessages returns empty string for empty array', () => {
+            const result = LogObserver.formatLogMessages([]);
+            expect(result).toBe('');
+        });
+
+        test('formatLogMessages includes timestamp, level, and message', () => {
+            const timestamp = new Date('2024-01-01T12:00:00.000Z');
+            const messages = [{ level: 'info' as const, message: 'test message', timestamp }];
+            const result = LogObserver.formatLogMessages(messages);
+            expect(result).toContain('2024-01-01T12:00:00.000Z');
+            expect(result).toContain('INFO');
+            expect(result).toContain('test message');
+        });
+
+        test('formatLogMessages formats multiple messages with newlines', () => {
+            const timestamp = new Date('2024-01-01T12:00:00.000Z');
+            const messages = [
+                { level: 'info' as const, message: 'first', timestamp },
+                { level: 'error' as const, message: 'second', timestamp },
+            ];
+            const result = LogObserver.formatLogMessages(messages);
+            const lines = result.split('\n');
+            expect(lines).toHaveLength(2);
+            expect(lines[0]).toContain('INFO');
+            expect(lines[0]).toContain('first');
+            expect(lines[1]).toContain('ERROR');
+            expect(lines[1]).toContain('second');
+        });
+    });
+
+    describe('RazorLogObserver', () => {
+        test('formatLogMessages returns empty string for empty array', () => {
+            const result = RazorLogObserver.formatLogMessages([]);
+            expect(result).toBe('');
+        });
+
+        test('formatLogMessages includes timestamp and message', () => {
+            const timestamp = new Date('2024-01-01T12:00:00.000Z');
+            const messages = [{ message: 'razor log entry', timestamp }];
+            const result = RazorLogObserver.formatLogMessages(messages);
+            expect(result).toContain('2024-01-01T12:00:00.000Z');
+            expect(result).toContain('razor log entry');
+        });
+
+        test('formatLogMessages formats multiple messages with newlines', () => {
+            const timestamp = new Date('2024-01-01T12:00:00.000Z');
+            const messages = [
+                { message: 'first razor', timestamp },
+                { message: 'second razor', timestamp },
+            ];
+            const result = RazorLogObserver.formatLogMessages(messages);
+            const lines = result.split('\n');
+            expect(lines).toHaveLength(2);
+            expect(lines[0]).toContain('first razor');
+            expect(lines[1]).toContain('second razor');
+        });
+    });
+});