Fetch exception text separately from console output (#969)

Co-authored-by: Tim Jacomb <[email protected]>

Author: das7pad

src/main/frontend/common/RestClient.tsx

@@ -49,6 +49,8 @@ export interface StepLogBufferInfo {
     promise: Promise<ConsoleLogData | null>;
   };
   fullyFetched?: boolean;
+  exceptionText?: string[];
+  pendingExceptionText?: Promise<string[]>;
 }
 
 // Returned from API, gets converted to 'StepLogBufferInfo'.
@@ -104,6 +106,18 @@ export async function getConsoleTextOffset(
   }
 }
 
+export async function getExceptionText(stepId: string): Promise<string[]> {
+  try {
+    const response = await fetch(`exceptionText?nodeId=${stepId}`);
+    if (!response.ok) throw response.statusText;
+    const text = await response.text();
+    return text.split("\n");
+  } catch (e) {
+    console.error(`Caught error when fetching console: '${e}'`);
+    return [];
+  }
+}
+
 export async function getConsoleBuildOutput(): Promise<string | null> {
   try {
     const response = await fetch(`consoleBuildOutput`);

src/main/frontend/pipeline-console-view/pipeline-console/main/ConsoleLogCard.spec.tsx

@@ -52,6 +52,7 @@ describe("ConsoleLogCard", () => {
     onMoreConsoleClick: () => {
       console.log("onMoreConsoleClick triggered");
     },
+    fetchExceptionText: () => {},
   } as ConsoleLogCardProps;
 
   it("renders step header only when not expanded", async () => {

src/main/frontend/pipeline-console-view/pipeline-console/main/ConsoleLogCard.tsx

@@ -29,6 +29,7 @@ export default function ConsoleLogCard({
   isExpanded,
   onMoreConsoleClick,
   onStepToggle,
+  fetchExceptionText,
 }: ConsoleLogCardProps) {
   useEffect(() => {
     if (isExpanded) {
@@ -53,15 +54,7 @@ export default function ConsoleLogCard({
 
   const inputStep = step.inputStep;
   if (inputStep && !inputStep.parameters) {
-    return (
-      <InputStep
-        step={step}
-        stepBuffer={stepBuffer}
-        isExpanded={isExpanded}
-        onStepToggle={onStepToggle}
-        onMoreConsoleClick={onMoreConsoleClick}
-      />
-    );
+    return <InputStep step={step} />;
   }
 
   return (
@@ -151,6 +144,7 @@ export default function ConsoleLogCard({
           step={step}
           stepBuffer={stepBuffer}
           onMoreConsoleClick={onMoreConsoleClick}
+          fetchExceptionText={fetchExceptionText}
           isExpanded={false}
           onStepToggle={onStepToggle}
         />
@@ -163,6 +157,7 @@ function ConsoleLogBody({
   step,
   stepBuffer,
   onMoreConsoleClick,
+  fetchExceptionText,
 }: ConsoleLogCardProps) {
   const prettySizeString = (size: number) => {
     const kib = 1024;
@@ -204,6 +199,7 @@ function ConsoleLogBody({
         <ConsoleLogStream
           logBuffer={stepBuffer}
           onMoreConsoleClick={onMoreConsoleClick}
+          fetchExceptionText={fetchExceptionText}
           step={step}
           maxHeightScale={0.65}
         />
@@ -218,4 +214,5 @@ export type ConsoleLogCardProps = {
   isExpanded: boolean;
   onStepToggle: (nodeId: string) => void;
   onMoreConsoleClick: (nodeId: string, startByte: number) => void;
+  fetchExceptionText: (nodeId: string) => void;
 };

src/main/frontend/pipeline-console-view/pipeline-console/main/ConsoleLogStream.spec.tsx

@@ -50,10 +50,26 @@ describe("ConsoleLogStream", () => {
     onMoreConsoleClick: () => {
       console.log("onMoreConsoleClick triggered");
     },
+    fetchExceptionText: vi.fn(),
   } as ConsoleLogStreamProps;
 
   it("renders step console", async () => {
     const { findByText } = render(TestComponent({ ...DefaultTestProps }));
     expect(findByText(/Hello, world!/));
+    expect(DefaultTestProps.fetchExceptionText).not.toBeCalled();
+  });
+
+  it("fetches exception text", async () => {
+    const { findByText } = render(
+      TestComponent({
+        ...DefaultTestProps,
+        step: {
+          ...baseStep,
+          state: Result.failure,
+        },
+      }),
+    );
+    expect(findByText(/Hello, world!/));
+    expect(DefaultTestProps.fetchExceptionText).toBeCalledWith(baseStep.id);
   });
 });

src/main/frontend/pipeline-console-view/pipeline-console/main/ConsoleLogStream.tsx

@@ -16,6 +16,7 @@ export default function ConsoleLogStream({
   step,
   logBuffer,
   onMoreConsoleClick,
+  fetchExceptionText,
 }: ConsoleLogStreamProps) {
   const appendInterval = useRef<number | null>(null);
   const [stickToBottom, setStickToBottom] = useState(false);
@@ -28,6 +29,12 @@ export default function ConsoleLogStream({
     };
   }, []);
 
+  useEffect(() => {
+    if (step.state === Result.failure) {
+      fetchExceptionText(step.id);
+    }
+  }, [step.id, step.state, fetchExceptionText]);
+
   useEffect(() => {
     if (stickToBottom && logBuffer.lines.length > 0 && canStickToBottom()) {
       // Scroll to bottom of the log stream
@@ -125,6 +132,7 @@ export default function ConsoleLogStream({
 export interface ConsoleLogStreamProps {
   logBuffer: StepLogBufferInfo;
   onMoreConsoleClick: (nodeId: string, startByte: number) => void;
+  fetchExceptionText: (nodeId: string) => void;
   step: StepInfo;
   maxHeightScale: number;
 }

src/main/frontend/pipeline-console-view/pipeline-console/main/NoStageStepsFallback.tsx

@@ -52,6 +52,7 @@ export function NoStageStepsFallback() {
           onMoreConsoleClick={() => {}}
           step={step}
           maxHeightScale={0.65}
+          fetchExceptionText={() => {}}
         />
       </div>
     </div>

src/main/frontend/pipeline-console-view/pipeline-console/main/PipelineConsole.tsx

@@ -36,6 +36,7 @@ export default function PipelineConsole() {
     handleStageSelect,
     onStepToggle,
     onMoreConsoleClick,
+    fetchExceptionText,
     loading,
   } = useStepsPoller({ currentRunPath, previousRunPath });
 
@@ -137,6 +138,7 @@ export default function PipelineConsole() {
                   expandedSteps={expandedSteps}
                   onStepToggle={onStepToggle}
                   onMoreConsoleClick={onMoreConsoleClick}
+                  fetchExceptionText={fetchExceptionText}
                 />
               )}
             </div>

src/main/frontend/pipeline-console-view/pipeline-console/main/StageView.spec.tsx

@@ -51,6 +51,7 @@ describe("StageView", () => {
           expandedSteps={["step-1"]}
           onStepToggle={vi.fn()}
           onMoreConsoleClick={vi.fn()}
+          fetchExceptionText={vi.fn()}
         />,
       );
     });

src/main/frontend/pipeline-console-view/pipeline-console/main/StageView.tsx

@@ -17,6 +17,7 @@ export default function StageView(props: StageViewProps) {
         expandedSteps={props.expandedSteps}
         onStepToggle={props.onStepToggle}
         onMoreConsoleClick={props.onMoreConsoleClick}
+        fetchExceptionText={props.fetchExceptionText}
       />
     </>
   );
@@ -29,4 +30,5 @@ export interface StageViewProps {
   expandedSteps: string[];
   onStepToggle: (nodeId: string) => void;
   onMoreConsoleClick: (nodeId: string, startByte: number) => void;
+  fetchExceptionText: (nodeId: string) => void;
 }

src/main/frontend/pipeline-console-view/pipeline-console/main/hooks/use-steps-poller.spec.ts

@@ -34,16 +34,18 @@ vi.mock("../../../../common/tree-api.ts", () => ({
 vi.mock("../PipelineConsoleModel.tsx", async () => ({
   ...(await vi.importActual("../PipelineConsoleModel.tsx")),
   getRunSteps: vi.fn(),
-  getConsoleTextOffset: vi.fn().mockResolvedValue({
-    text: "log line",
-    startByte: 0,
-    endByte: 100,
-  }),
+  getConsoleTextOffset: vi.fn(),
+  getExceptionText: vi.fn().mockResolvedValue(["Error message"]),
   POLL_INTERVAL: 50,
 }));
 
 beforeEach(() => {
   (model.getRunSteps as Mock).mockResolvedValue({ steps: mockSteps });
+  (model.getConsoleTextOffset as Mock).mockResolvedValue({
+    text: "log line\n",
+    startByte: 0,
+    endByte: 100,
+  });
   window.history.pushState({}, "", "/");
 });
 
@@ -66,6 +68,98 @@ it("selects default step if URL param is missing", async () => {
   unmount();
 });
 
+it("handles empty console log", async () => {
+  (model.getConsoleTextOffset as Mock).mockResolvedValue({
+    text: "",
+    startByte: 0,
+    endByte: 0,
+  });
+  const { result, unmount } = renderHook(() =>
+    useStepsPoller({ currentRunPath: "/run/1", previousRunPath: undefined }),
+  );
+
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-2"));
+  await waitFor(() =>
+    expect(result.current.openStageStepBuffers.get("step-2")).to.deep.equal({
+      startByte: 0,
+      endByte: 0,
+      lines: [],
+      fullyFetched: true,
+    }),
+  );
+
+  unmount();
+});
+
+it("handles empty console log lines before and after text", async () => {
+  (model.getConsoleTextOffset as Mock).mockResolvedValue({
+    text: "\nHello\n\n",
+    startByte: 0,
+    endByte: 0,
+  });
+  const { result, unmount } = renderHook(() =>
+    useStepsPoller({ currentRunPath: "/run/1", previousRunPath: undefined }),
+  );
+
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-2"));
+  await waitFor(() =>
+    expect(
+      result.current.openStageStepBuffers.get("step-2")?.lines,
+    ).to.deep.equal(["", "Hello", ""]),
+  );
+
+  unmount();
+});
+
+it("appends the exception message", async () => {
+  const { result, unmount } = renderHook(() =>
+    useStepsPoller({ currentRunPath: "/run/1", previousRunPath: undefined }),
+  );
+
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-2"));
+  await waitFor(() =>
+    expect(
+      result.current.openStageStepBuffers.get("step-2")?.lines,
+    ).to.deep.equal(["log line"]),
+  );
+  await act(() => result.current.fetchExceptionText("step-2"));
+
+  await waitFor(() =>
+    expect(
+      result.current.openStageStepBuffers.get("step-2")?.lines,
+    ).to.deep.equal(["log line", "Error message"]),
+  );
+
+  unmount();
+});
+
+it("handles empty console log and exception message", async () => {
+  (model.getConsoleTextOffset as Mock).mockResolvedValue({
+    text: "",
+    startByte: 0,
+    endByte: 0,
+  });
+  const { result, unmount } = renderHook(() =>
+    useStepsPoller({ currentRunPath: "/run/1", previousRunPath: undefined }),
+  );
+
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-2"));
+  await waitFor(() =>
+    expect(
+      result.current.openStageStepBuffers.get("step-2")?.lines,
+    ).to.deep.equal([]),
+  );
+  await act(() => result.current.fetchExceptionText("step-2"));
+
+  await waitFor(() =>
+    expect(
+      result.current.openStageStepBuffers.get("step-2")?.lines,
+    ).to.deep.equal(["Error message"]),
+  );
+
+  unmount();
+});
+
 it("selects the step from URL on initial load", async () => {
   window.history.pushState({}, "", "/?selected-node=step-1&start-byte=0");
   const { result, unmount } = renderHook(() =>