fix(diagnostics): capture console output in diagnostics exports (#1720)

<!-- Please read
https://github.com/SableClient/Sable/blob/dev/CONTRIBUTING.md before
submitting your pull request -->

### Description

<!-- Please include a summary of the change. Please also include
relevant motivation and context. List any dependencies that are required
for this change. -->

Fixes #

#### Type of change

- [x] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- [ ] This change requires a documentation update

### Checklist:

- [x] My code follows the style guidelines of this project
- [x] I have performed a self-review of my own code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings

### AI disclosure:

- [ ] Partially AI assisted (clarify which code was AI assisted and
briefly explain what it does).
- [ ] Fully AI generated (explain what all the generated code does in
moderate detail).
<!-- Write any explanation required here, but do not generate the
explanation using AI!! You must prove you understand what the code in
this PR does. -->

Author: eleboucher

src/app/utils/debugLogger.test.ts

@@ -79,6 +79,61 @@ describe('debug logger diagnostic capture', () => {
     expect(logger.getLogs().some((entry) => entry.message === 'before capture')).toBe(false);
   });
 
+  it('captures console output while a capture session is active and restores console after', () => {
+    const originalError = console.error;
+    const since = logger.startCapture();
+
+    console.error('sdk sync failed', { url: 'https://matrix.example/sync' });
+    console.warn('sdk retrying');
+    logger.stopCapture();
+
+    expect(console.error).toBe(originalError);
+    expect(logger.getFilteredLogs({ since })).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          level: 'error',
+          namespace: 'console',
+          message: expect.stringContaining('sdk sync failed'),
+        }),
+        expect.objectContaining({
+          level: 'warn',
+          namespace: 'console',
+          message: 'sdk retrying',
+        }),
+      ])
+    );
+  });
+
+  it('scrubs sensitive data from console-captured entries', () => {
+    logger.startCapture();
+
+    console.error(
+      'sync failed https://matrix.example/_matrix/client/v3/sync?access_token=syt_secret for @alice:example.org in !room:example.org'
+    );
+    logger.stopCapture();
+
+    const stored = JSON.stringify(logger.getLogs());
+    expect(stored).not.toContain('matrix.example');
+    expect(stored).not.toContain('syt_secret');
+    expect(stored).not.toContain('alice');
+    expect(stored).not.toContain('!room:example.org');
+    expect(stored).toContain('[REDACTED_URL]');
+  });
+
+  it('does not recurse when debug logging is enabled during capture', () => {
+    logger.setEnabled(true);
+    logger.startCapture();
+
+    expect(() => console.error('from app')).not.toThrow();
+
+    logger.stopCapture();
+    logger.setEnabled(false);
+    const consoleEntries = logger
+      .getLogs()
+      .filter((entry) => entry.namespace === 'console' && entry.message.includes('from app'));
+    expect(consoleEntries).toHaveLength(1);
+  });
+
   it('sanitizes entries before storing them in memory', () => {
     logger.log('error', 'network', 'test', 'request https://matrix.example/@alice:example.org', {
       access_token: 'secret',

src/app/utils/debugLogger.ts

@@ -35,6 +35,29 @@ type LogListener = (entry: LogEntry) => void;
 
 const BREADCRUMB_DISABLED_KEY = 'sable_sentry_breadcrumb_disabled';
 
+type ConsoleMethod = 'error' | 'warn' | 'info' | 'log' | 'debug';
+
+const CONSOLE_METHODS: ConsoleMethod[] = ['error', 'warn', 'info', 'log', 'debug'];
+
+const MAX_CONSOLE_MESSAGE_LENGTH = 1000;
+
+const formatConsoleArgs = (args: unknown[]): string => {
+  const text = args
+    .map((arg) => {
+      if (typeof arg === 'string') return arg;
+      if (arg instanceof Error) return arg.stack ?? arg.message;
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(' ');
+  return text.length > MAX_CONSOLE_MESSAGE_LENGTH
+    ? `${text.slice(0, MAX_CONSOLE_MESSAGE_LENGTH)}…`
+    : text;
+};
+
 class DebugLoggerService {
   private logs: LogEntry[] = [];
 
@@ -52,6 +75,12 @@ class DebugLoggerService {
 
   private sentryStats = { errors: 0, warnings: 0 };
 
+  private originalConsole: Partial<Record<ConsoleMethod, (...args: unknown[]) => void>> = {};
+
+  private consoleIntercepted = false;
+
+  private writingToConsole = false;
+
   constructor() {
     // Check if debug logging is enabled from localStorage
     this.enabled = localStorage.getItem('sable_internal_debug') === '1';
@@ -91,6 +120,7 @@ class DebugLoggerService {
     this.clear();
     this.captureActive = true;
     this.captureSince = Date.now();
+    this.interceptConsole();
     this.log('info', 'general', 'diagnostics', 'Diagnostic capture started');
     return this.captureSince;
   }
@@ -99,9 +129,44 @@ class DebugLoggerService {
     if (!this.captureActive) return this.captureSince;
     this.log('info', 'general', 'diagnostics', 'Diagnostic capture stopped');
     this.captureActive = false;
+    this.restoreConsole();
     return this.captureSince;
   }
 
+  /**
+   * Funnels console output (including matrix-js-sdk's logger, which writes to the
+   * console) into the capture buffer for the duration of a diagnostics session.
+   */
+  private interceptConsole(): void {
+    if (this.consoleIntercepted) return;
+    this.consoleIntercepted = true;
+    CONSOLE_METHODS.forEach((method) => {
+      const original = console[method] as (...args: unknown[]) => void;
+      this.originalConsole[method] = original;
+      console[method] = (...args: unknown[]) => {
+        original.apply(console, args);
+        if (this.writingToConsole) return;
+        const level: LogLevel = method === 'log' ? 'debug' : method;
+        this.log(
+          level,
+          level === 'error' ? 'error' : 'general',
+          'console',
+          formatConsoleArgs(args)
+        );
+      };
+    });
+  }
+
+  private restoreConsole(): void {
+    if (!this.consoleIntercepted) return;
+    this.consoleIntercepted = false;
+    CONSOLE_METHODS.forEach((method) => {
+      const original = this.originalConsole[method];
+      if (original) console[method] = original;
+    });
+    this.originalConsole = {};
+  }
+
   public addListener(listener: LogListener): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -175,7 +240,12 @@ class DebugLoggerService {
     // Also log to console for developer convenience
     const prefix = `[sable:${category}:${namespace}]`;
     const consoleLevel = level === 'debug' ? 'log' : level;
-    console[consoleLevel](prefix, message, data !== undefined ? data : '');
+    this.writingToConsole = true;
+    try {
+      console[consoleLevel](prefix, message, data !== undefined ? data : '');
+    } finally {
+      this.writingToConsole = false;
+    }
   }
 
   public getBreadcrumbCategoryEnabled(category: LogCategory): boolean {