feat: linkify stack traces in log files

Preserve complete clipboard content and bound document link scans by total characters and lines so saved log files can be handled safely.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6e50dc26-84c4-4532-a7d3-88f6fe016780

Author: wenytang-ms

src/stackTraceLinkProvider.ts

@@ -12,25 +12,23 @@ import { getJavaExtensionAPI, isJavaExtEnabled, ServerMode } from "./utility";
 const ANALYZE_STACK_TRACE_COMMAND = "java.debug.analyzeStackTrace";
 const NAVIGATE_TO_STACK_FRAME_COMMAND = "_java.debug.navigateToStackFrame";
 
-// Only linkify pasted traces in untitled (scratch) documents - including the one opened by the
-// `Analyze Stack Trace` command. Kept deliberately narrow: a `.log` opened without a Java project
-// couldn't resolve anyway, so we don't scan `.log` files or every plaintext file the user opens.
+// Linkify stack traces in scratch documents and .log files. Other plaintext documents stay
+// excluded so the extension does not passively scan unrelated files.
 const STACK_TRACE_DOCUMENT_SELECTOR: DocumentSelector = [
     { scheme: "untitled" },
+    { pattern: "**/*.log" },
 ];
 
-// Guard against pathological input: cap the length of a scanned line (mitigates ReDoS on the
-// nested-quantifier regex) and the number of links produced for very large pasted traces.
+// Bound the work performed for large documents and pathological input. The per-line cap mitigates
+// ReDoS in the nested-quantifier regex; the document budgets keep large logs from being fully scanned.
 const MAX_SCANNED_LINE_LENGTH = 1000;
+const MAX_SCANNED_LINES_PER_DOCUMENT = 10000;
+const MAX_SCANNED_CHARACTERS_PER_DOCUMENT = 1000000;
 const MAX_LINKS_PER_DOCUMENT = 2000;
 
 // Only resolve to source locations the language server is expected to return.
 const ALLOWED_SOURCE_SCHEMES = new Set<string>(["file", "jdt"]);
 
-// Bound both stack-trace detection and scratch-document prefill so a large clipboard cannot create
-// an expensive untitled document (and keeps the detection regex input bounded).
-const MAX_CLIPBOARD_PREFILL_LENGTH = 20000;
-
 interface IStackFrameLinkArgs {
     stackTrace: string;
     methodName: string;
@@ -66,12 +64,20 @@ function isStackFrameLinkArgs(args: unknown): args is IStackFrameLinkArgs {
 export class JavaStackTraceLinkProvider implements DocumentLinkProvider {
     public provideDocumentLinks(document: TextDocument, token: CancellationToken): ProviderResult<DocumentLink[]> {
         const links: DocumentLink[] = [];
-        for (let i = 0; i < document.lineCount; i++) {
+        let scannedCharacters = 0;
+        const linesToScan = Math.min(document.lineCount, MAX_SCANNED_LINES_PER_DOCUMENT);
+        for (let i = 0; i < linesToScan; i++) {
             if (token.isCancellationRequested || links.length >= MAX_LINKS_PER_DOCUMENT) {
                 break;
             }
 
             const lineText = document.lineAt(i).text;
+            const lineScanCost = lineText.length + 1;
+            if (scannedCharacters + lineScanCost > MAX_SCANNED_CHARACTERS_PER_DOCUMENT) {
+                break;
+            }
+            scannedCharacters += lineScanCost;
+
             if (lineText.length > MAX_SCANNED_LINE_LENGTH) {
                 continue;
             }
@@ -145,14 +151,13 @@ async function navigateToStackFrame(args: unknown): Promise<void> {
 }
 
 /**
- * Opens a scratch document prefilled with bounded clipboard content. The document link provider
- * scans the content after the document opens and makes any stack frames clickable.
+ * Opens a scratch document prefilled with the clipboard content. The document link provider scans
+ * a bounded portion after the document opens and makes any stack frames clickable.
  */
 async function analyzeStackTrace(): Promise<void> {
     // The command itself is auto-instrumented via instrumentOperationAsVsCodeCommand, so no
     // manual telemetry is needed here to track invocations.
-    const clipboard = await env.clipboard.readText();
-    const clipboardContent = clipboard.slice(0, MAX_CLIPBOARD_PREFILL_LENGTH);
+    const clipboardContent = await env.clipboard.readText();
     const document = await workspace.openTextDocument({ language: "log", content: clipboardContent });
     await window.showTextDocument(document);
 }

test/stackTraceLinkProvider.test.ts

@@ -7,30 +7,45 @@ import { CancellationTokenSource, workspace } from "vscode";
 import { JavaStackTraceLinkProvider } from "../src/stackTraceLinkProvider";
 
 suite("JavaStackTraceLinkProvider", () => {
-    test("encodes command URI arguments as an array", async () => {
-        const stackTrace = "com.example.App.main(App.java:42)";
-        const document = await workspace.openTextDocument({
-            language: "log",
-            content: `\tat ${stackTrace}`,
-        });
+    async function provideLinks(content: string) {
+        const document = await workspace.openTextDocument({ language: "log", content });
         const cancellation = new CancellationTokenSource();
 
         try {
-            const links = await Promise.resolve(
+            return await Promise.resolve(
                 new JavaStackTraceLinkProvider().provideDocumentLinks(document, cancellation.token),
             );
-            assert.ok(links);
-            assert.strictEqual(links.length, 1);
-
-            const target = links[0].target;
-            assert.ok(target);
-            assert.deepStrictEqual(JSON.parse(decodeURIComponent(target.query)), [{
-                stackTrace,
-                methodName: "com.example.App.main",
-                lineNumber: 42,
-            }]);
         } finally {
             cancellation.dispose();
         }
+    }
+
+    test("encodes command URI arguments as an array", async () => {
+        const stackTrace = "com.example.App.main(App.java:42)";
+        const links = await provideLinks(`\tat ${stackTrace}`);
+
+        assert.ok(links);
+        assert.strictEqual(links.length, 1);
+
+        const target = links[0].target;
+        assert.ok(target);
+        assert.deepStrictEqual(JSON.parse(decodeURIComponent(target.query)), [{
+            stackTrace,
+            methodName: "com.example.App.main",
+            lineNumber: 42,
+        }]);
+    });
+
+    test("stops scanning after the document character budget", async () => {
+        const longPrefix = `${"x".repeat(1000)}\n`.repeat(1000);
+        const links = await provideLinks(`${longPrefix}\tat com.example.App.main(App.java:42)`);
+
+        assert.deepStrictEqual(links, []);
+    });
+
+    test("stops scanning after the document line budget", async () => {
+        const links = await provideLinks(`${"\n".repeat(10000)}\tat com.example.App.main(App.java:42)`);
+
+        assert.deepStrictEqual(links, []);
     });
 });