Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor(frontend): migrate revision detail to react (#19890)

p0nyeb569ecaa281
diff --git a/frontend/src/components/MonacoEditor/editor.ts b/frontend/src/components/MonacoEditor/editor.ts
index 1eb9e88c2a..65dd80be3e 100644
--- a/frontend/src/components/MonacoEditor/editor.ts
+++ b/frontend/src/components/MonacoEditor/editor.ts
@@ -1,4 +1,5 @@
import type * as MonacoType from "monaco-editor";
+import type { Language } from "@/types";
import { defer } from "@/utils";
import { loadMonacoEditor } from "./lazy-editor";
import { initializeMonacoServices } from "./services";
@@ -77,6 +78,14 @@ export const createMonacoDiffEditor = async (config: {
return editor;
};
+export const setMonacoModelLanguage = async (
+ model: MonacoType.editor.ITextModel,
+ language: Language
+): Promise<void> => {
+ const monaco = await loadMonacoEditor();
+ monaco.editor.setModelLanguage(model, language);
+};
+
export const defaultEditorOptions =
(): MonacoType.editor.IStandaloneEditorConstructionOptions => {
return {
diff --git a/frontend/src/components/Revision/RevisionDetailPanel.vue b/frontend/src/components/Revision/RevisionDetailPanel.vue
deleted file mode 100644
index 75fc2fc68c..0000000000
--- a/frontend/src/components/Revision/RevisionDetailPanel.vue
+++ /dev/null
@@ -1,161 +0,0 @@
-<template>
- <div class="focus:outline-hidden" tabindex="0" v-bind="$attrs">
- <div
- v-if="state.loading"
- class="flex items-center justify-center py-2 text-gray-400 text-sm"
- >
- <BBSpin />
- </div>
- <main v-else-if="revision" class="flex flex-col relative gap-y-6">
- <!-- Highlight Panel -->
- <div class="flex flex-col gap-y-4">
- <!-- Version Title -->
- <h2 class="text-2xl font-semibold text-main">
- {{ revision.version }}
- </h2>
-
- <!-- Metadata Row -->
- <div class="flex items-center gap-x-3 text-sm text-control-light">
- <span>{{ getRevisionType(revision.type) }}</span>
- <span v-if="formattedCreateTime">•</span>
- <span v-if="formattedCreateTime">
- {{ formattedCreateTime }}
- </span>
- </div>
- </div>
-
- <div class="flex flex-col gap-y-6">
- <!-- Task Run Logs Section -->
- <div v-if="revision.taskRun" class="flex flex-col gap-y-2">
- <div class="flex items-center justify-between">
- <p class="text-lg text-main">
- {{ $t("issue.task-run.logs") }}
- </p>
- <router-link
- v-if="taskFullLink"
- :to="taskFullLink"
- class="flex items-center gap-x-1 text-sm text-control-light hover:text-accent transition-colors"
- >
- {{ $t("common.show-more") }}
- <ArrowUpRightIcon class="w-4 h-4" />
- </router-link>
- </div>
- <TaskRunLogViewer :task-run-name="revision.taskRun" />
- </div>
-
- <!-- Statement Section -->
- <div class="flex flex-col gap-y-2">
- <p class="flex items-center text-lg text-main gap-x-2">
- {{ $t("common.statement") }}
- <span
- v-if="formattedStatementSize"
- class="text-sm font-normal text-control-light"
- >
- ({{ formattedStatementSize }})
- </span>
- <CopyButton size="small" :content="state.statement" />
- </p>
- <MonacoEditor
- class="h-auto max-h-[600px] min-h-[120px] border rounded-md text-sm overflow-clip relative"
- :content="state.statement"
- :readonly="true"
- :auto-height="{ min: 120, max: 600 }"
- />
- </div>
- </div>
- </main>
- </div>
-</template>
-
-<script lang="ts" setup>
-import { ArrowUpRightIcon } from "lucide-vue-next";
-import { computed, reactive, watch } from "vue";
-import { BBSpin } from "@/bbkit";
-import { MonacoEditor } from "@/components/MonacoEditor";
-import { TaskRunLogViewer } from "@/components/RolloutV1/components/TaskRun/TaskRunLogViewer";
-import { CopyButton } from "@/components/v2";
-import { sheetServiceClientConnect } from "@/connect";
-import { useRevisionStore } from "@/store";
-import { getTimeForPbTimestampProtoEs } from "@/types";
-import type { Database } from "@/types/proto-es/v1/database_service_pb";
-import type { Revision } from "@/types/proto-es/v1/revision_service_pb";
-import { bytesToString, formatAbsoluteDateTime } from "@/utils";
-import { extractTaskLink, getRevisionType } from "@/utils/v1/revision";
-
-interface LocalState {
- loading: boolean;
- statement: string;
-}
-
-const props = defineProps<{
- database: Database;
- revisionName: string;
-}>();
-
-const revisionStore = useRevisionStore();
-const state = reactive<LocalState>({
- loading: false,
- statement: "",
-});
-
-const revision = computed((): Revision | undefined =>
- revisionStore.getRevisionByName(props.revisionName)
-);
-
-const taskFullLink = computed(() => {
- if (!revision.value?.taskRun) {
- return "";
- }
- return extractTaskLink(revision.value.taskRun);
-});
-
-const formattedCreateTime = computed(() => {
- if (!revision.value) {
- return "";
- }
- return formatAbsoluteDateTime(
- getTimeForPbTimestampProtoEs(revision.value.createTime)
- );
-});
-
-const formattedStatementSize = computed(() => {
- if (!state.statement) {
- return "";
- }
- return bytesToString(new TextEncoder().encode(state.statement).length);
-});
-
-watch(
- () => props.revisionName,
- async (revisionName) => {
- if (!revisionName) {
- return;
- }
-
- state.loading = true;
- state.statement = "";
-
- try {
- const rev = await revisionStore.getOrFetchRevisionByName(revisionName);
- if (rev?.sheet) {
- try {
- const sheet = await sheetServiceClientConnect.getSheet({
- name: rev.sheet,
- raw: true,
- });
- if (sheet.content) {
- state.statement = new TextDecoder().decode(sheet.content);
- }
- } catch (error) {
- console.error("Failed to fetch sheet content", error);
- }
- }
- } catch (error) {
- console.error("Failed to fetch revision details", error);
- } finally {
- state.loading = false;
- }
- },
- { immediate: true }
-);
-</script>
diff --git a/frontend/src/components/Revision/index.ts b/frontend/src/components/Revision/index.ts
index de4e686a24..2e60e931af 100644
--- a/frontend/src/components/Revision/index.ts
+++ b/frontend/src/components/Revision/index.ts
@@ -1,4 +1,3 @@
import RevisionDataTable from "./RevisionDataTable.vue";
-import RevisionDetailPanel from "./RevisionDetailPanel.vue";
-export { RevisionDataTable, RevisionDetailPanel };
+export { RevisionDataTable };
diff --git a/frontend/src/react/components/monaco/ReadonlyMonaco.test.tsx b/frontend/src/react/components/monaco/ReadonlyMonaco.test.tsx
new file mode 100644
index 0000000000..dec862fcb6
--- /dev/null
+++ b/frontend/src/react/components/monaco/ReadonlyMonaco.test.tsx
@@ -0,0 +1,162 @@
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { ReadonlyMonaco } from "./ReadonlyMonaco";
+
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const mocks = vi.hoisted(() => {
+ const createMonacoEditor = vi.fn();
+ const setMonacoModelLanguage = vi.fn();
+ return {
+ createMonacoEditor,
+ setMonacoModelLanguage,
+ };
+});
+
+vi.mock("@/components/MonacoEditor/editor", () => ({
+ createMonacoEditor: mocks.createMonacoEditor,
+ setMonacoModelLanguage: mocks.setMonacoModelLanguage,
+}));
+
+const createDeferred = <T,>() => {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((res) => {
+ resolve = res;
+ });
+ return { promise, resolve };
+};
+
+const flushAsync = () =>
+ new Promise<void>((resolve) => {
+ setTimeout(resolve, 0);
+ });
+
+const createEditor = () => {
+ let contentHeight = 240;
+ let contentSizeHandler:
+ | ((event: {
+ contentHeight: number;
+ contentHeightChanged: boolean;
+ }) => void)
+ | undefined;
+ const model = {};
+
+ return {
+ model,
+ setValue: vi.fn(),
+ getValue: vi.fn(() => "first line"),
+ getModel: vi.fn(() => model),
+ getContentHeight: vi.fn(() => contentHeight),
+ onDidContentSizeChange: vi.fn((handler) => {
+ contentSizeHandler = handler;
+ return { dispose: vi.fn() };
+ }),
+ emitContentHeight(nextHeight: number) {
+ contentHeight = nextHeight;
+ contentSizeHandler?.({
+ contentHeight: nextHeight,
+ contentHeightChanged: true,
+ });
+ },
+ dispose: vi.fn(),
+ };
+};
+
+const renderIntoContainer = (element: ReturnType<typeof createElement>) => {
+ const container = document.createElement("div");
+ const root = createRoot(container);
+
+ act(() => {
+ root.render(element);
+ });
+
+ return {
+ container,
+ root,
+ rerender: (nextElement: ReturnType<typeof createElement>) => {
+ act(() => {
+ root.render(nextElement);
+ });
+ },
+ unmount: () =>
+ act(() => {
+ root.unmount();
+ }),
+ };
+};
+
+beforeEach(() => {
+ mocks.createMonacoEditor.mockReset();
+ mocks.setMonacoModelLanguage.mockReset();
+});
+
+describe("ReadonlyMonaco", () => {
+ test("reconciles the latest props after delayed editor creation", async () => {
+ const deferred = createDeferred<Awaited<ReturnType<typeof createEditor>>>();
+ mocks.createMonacoEditor.mockReturnValue(deferred.promise);
+ const editor = createEditor();
+
+ const { unmount, rerender } = renderIntoContainer(
+ createElement(ReadonlyMonaco, {
+ content: "initial",
+ language: "sql",
+ })
+ );
+
+ rerender(
+ createElement(ReadonlyMonaco, {
+ content: "updated",
+ language: "json",
+ })
+ );
+
+ await act(async () => {
+ deferred.resolve(editor);
+ await deferred.promise;
+ await flushAsync();
+ });
+
+ expect(editor.setValue).toHaveBeenCalledWith("updated");
+ expect(mocks.setMonacoModelLanguage).toHaveBeenCalledWith(
+ editor.model,
+ "json"
+ );
+
+ unmount();
+ });
+
+ test("sizes from Monaco content height changes", async () => {
+ const deferred = createDeferred<ReturnType<typeof createEditor>>();
+ mocks.createMonacoEditor.mockReturnValue(deferred.promise);
+ const editor = createEditor();
+
+ const { container, unmount } = renderIntoContainer(
+ createElement(ReadonlyMonaco, {
+ content: "a very long single line that wraps in Monaco",
+ })
+ );
+
+ await act(async () => {
+ deferred.resolve(editor);
+ await deferred.promise;
+ await flushAsync();
+ });
+
+ expect(
+ (container.firstElementChild as HTMLElement | null)?.style.height
+ ).toBe("240px");
+
+ act(() => {
+ editor.emitContentHeight(480);
+ });
+
+ expect(
+ (container.firstElementChild as HTMLElement | null)?.style.height
+ ).toBe("480px");
+
+ unmount();
+ });
+});
diff --git a/frontend/src/react/components/monaco/ReadonlyMonaco.tsx b/frontend/src/react/components/monaco/ReadonlyMonaco.tsx
new file mode 100644
index 0000000000..e9f04e6287
--- /dev/null
+++ b/frontend/src/react/components/monaco/ReadonlyMonaco.tsx
@@ -0,0 +1,130 @@
+import { useEffect, useRef, useState } from "react";
+import {
+ createMonacoEditor,
+ setMonacoModelLanguage,
+} from "@/components/MonacoEditor/editor";
+import type { IStandaloneCodeEditor } from "@/components/MonacoEditor/types";
+import { cn } from "@/react/lib/utils";
+import type { Language } from "@/types";
+
+export interface ReadonlyMonacoProps {
+ content: string;
+ language?: Language;
+ className?: string;
+ min?: number;
+ max?: number;
+}
+
+export function ReadonlyMonaco({
+ content,
+ language = "sql",
+ className = "",
+ min = 120,
+ max = 600,
+}: ReadonlyMonacoProps) {
+ const containerRef = useRef<HTMLDivElement>(null);
+ const editorRef = useRef<IStandaloneCodeEditor | null>(null);
+ const contentRef = useRef(content);
+ const languageRef = useRef(language);
+ const [contentHeight, setContentHeight] = useState(min);
+ const clampMeasuredHeight = (height: number): number => {
+ return Math.min(max, Math.max(min, height));
+ };
+
+ contentRef.current = content;
+ languageRef.current = language;
+
+ useEffect(() => {
+ let disposed = false;
+ let contentSizeSubscription: { dispose(): void } | null = null;
+
+ (async () => {
+ if (!containerRef.current) return;
+
+ const editor = await createMonacoEditor({
+ container: containerRef.current,
+ options: {
+ language: languageRef.current,
+ value: contentRef.current,
+ readOnly: true,
+ domReadOnly: true,
+ },
+ });
+
+ if (disposed) {
+ editor.dispose();
+ return;
+ }
+
+ editorRef.current = editor;
+
+ contentSizeSubscription = editor.onDidContentSizeChange((event) => {
+ if (!event.contentHeightChanged) return;
+ setContentHeight(event.contentHeight);
+ });
+
+ if (editor.getValue() !== contentRef.current) {
+ editor.setValue(contentRef.current);
+ }
+
+ setContentHeight(editor.getContentHeight());
+
+ const model = editor.getModel();
+ if (model) {
+ await setMonacoModelLanguage(model, languageRef.current);
+ if (disposed) {
+ contentSizeSubscription?.dispose();
+ editor.dispose();
+ return;
+ }
+ }
+
+ if (disposed) {
+ contentSizeSubscription?.dispose();
+ editor.dispose();
+ return;
+ }
+ })();
+
+ return () => {
+ disposed = true;
+ contentSizeSubscription?.dispose();
+ editorRef.current?.dispose();
+ editorRef.current = null;
+ };
+ }, []);
+
+ useEffect(() => {
+ const editor = editorRef.current;
+ if (!editor) return;
+ if (editor.getValue() !== contentRef.current) {
+ editor.setValue(contentRef.current);
+ }
+ setContentHeight(editor.getContentHeight());
+ }, [content]);
+
+ useEffect(() => {
+ const editor = editorRef.current;
+ const model = editor?.getModel();
+ if (!model) return;
+
+ (async () => {
+ await setMonacoModelLanguage(model, languageRef.current);
+ })();
+ }, [language]);
+
+ const height = clampMeasuredHeight(contentHeight);
+
+ return (
+ <div
+ ref={containerRef}
+ className={cn(
+ "w-full overflow-clip rounded-md border text-sm",
+ className
+ )}
+ style={{ height }}
+ />
+ );
+}
+
+export default ReadonlyMonaco;
diff --git a/frontend/src/react/components/monaco/height.test.ts b/frontend/src/react/components/monaco/height.test.ts
new file mode 100644
index 0000000000..49a0297fba
--- /dev/null
+++ b/frontend/src/react/components/monaco/height.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, test } from "vitest";
+import { clampEditorHeight } from "./height";
+
+describe("clampEditorHeight", () => {
+ test("clamps short content to the minimum height", () => {
+ expect(
+ clampEditorHeight({
+ lineCount: 1,
+ lineHeight: 24,
+ min: 120,
+ max: 600,
+ })
+ ).toBe(120);
+ });
+
+ test("returns the computed height when it is within bounds", () => {
+ expect(
+ clampEditorHeight({
+ lineCount: 6,
+ lineHeight: 24,
+ min: 120,
+ max: 600,
+ })
+ ).toBe(144);
+ });
+
+ test("clamps tall content to the maximum height", () => {
+ expect(
+ clampEditorHeight({
+ lineCount: 40,
+ lineHeight: 24,
+ min: 120,
+ max: 600,
+ })
+ ).toBe(600);
+ });
+});
diff --git a/frontend/src/react/components/monaco/height.ts b/frontend/src/react/components/monaco/height.ts
new file mode 100644
index 0000000000..5edffb86d1
--- /dev/null
+++ b/frontend/src/react/components/monaco/height.ts
@@ -0,0 +1,15 @@
+export interface ClampEditorHeightOptions {
+ lineCount: number;
+ lineHeight: number;
+ min: number;
+ max: number;
+}
+
+export function clampEditorHeight({
+ lineCount,
+ lineHeight,
+ min,
+ max,
+}: ClampEditorHeightOptions): number {
+ return Math.min(max, Math.max(min, lineCount * lineHeight));
+}
diff --git a/frontend/src/react/components/monaco/index.ts b/frontend/src/react/components/monaco/index.ts
new file mode 100644
index 0000000000..2f9a1571cb
--- /dev/null
+++ b/frontend/src/react/components/monaco/index.ts
@@ -0,0 +1,2 @@
+export { ReadonlyMonaco } from "./ReadonlyMonaco";
+export { clampEditorHeight } from "./height";
diff --git a/frontend/src/react/components/revision/RevisionDetailPanel.tsx b/frontend/src/react/components/revision/RevisionDetailPanel.tsx
new file mode 100644
index 0000000000..7df39f5bb6
--- /dev/null
+++ b/frontend/src/react/components/revision/RevisionDetailPanel.tsx
@@ -0,0 +1,228 @@
+import { ArrowUpRight, LoaderCircle } from "lucide-react";
+import { type MouseEvent, useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { sheetServiceClientConnect } from "@/connect";
+import { ReadonlyMonaco } from "@/react/components/monaco";
+import { TaskRunLogViewer } from "@/react/components/task-run-log";
+import { useVueState } from "@/react/hooks/useVueState";
+import { router } from "@/router";
+import { pushNotification, useRevisionStore } from "@/store";
+import { getTimeForPbTimestampProtoEs } from "@/types";
+import { bytesToString, formatAbsoluteDateTime } from "@/utils";
+import { extractTaskLink, getRevisionType } from "@/utils/v1/revision";
+
+interface CopyButtonProps {
+ content: string;
+}
+
+function execCommandCopy(text: string): boolean {
+ const textarea = document.createElement("textarea");
+ textarea.value = text;
+ textarea.style.position = "fixed";
+ textarea.style.opacity = "0";
+ document.body.appendChild(textarea);
+ textarea.select();
+ try {
+ return document.execCommand("copy");
+ } catch {
+ return false;
+ } finally {
+ document.body.removeChild(textarea);
+ }
+}
+
+async function copyToClipboard(text: string): Promise<boolean> {
+ if (navigator.clipboard) {
+ try {
+ await navigator.clipboard.writeText(text);
+ return true;
+ } catch {
+ // Fall through to execCommand fallback.
+ }
+ }
+ return execCommandCopy(text);
+}
+
+function CopyButton({ content }: CopyButtonProps) {
+ const { t } = useTranslation();
+
+ const handleCopy = async () => {
+ if (!content) {
+ return;
+ }
+
+ if (await copyToClipboard(content)) {
+ pushNotification({
+ module: "bytebase",
+ style: "SUCCESS",
+ title: t("common.copied"),
+ });
+ }
+ };
+
+ return (
+ <button
+ type="button"
+ className="text-sm text-control-light transition-colors hover:text-accent disabled:cursor-not-allowed disabled:text-control-light/40"
+ title={t("common.copy")}
+ aria-label={t("common.copy")}
+ disabled={!content}
+ onClick={handleCopy}
+ >
+ {t("common.copy")}
+ </button>
+ );
+}
+
+export interface RevisionDetailPanelProps {
+ revisionName: string;
+}
+
+export function RevisionDetailPanel({
+ revisionName,
+}: RevisionDetailPanelProps) {
+ const { t } = useTranslation();
+ const revisionStore = useRevisionStore();
+ const revision = useVueState(() =>
+ revisionStore.getRevisionByName(revisionName)
+ );
+ const [loading, setLoading] = useState(false);
+ const [statement, setStatement] = useState("");
+
+ useEffect(() => {
+ if (!revisionName) {
+ setLoading(false);
+ setStatement("");
+ return;
+ }
+
+ let cancelled = false;
+
+ setLoading(true);
+ setStatement("");
+
+ void revisionStore
+ .getOrFetchRevisionByName(revisionName)
+ .then(async (rev) => {
+ if (!rev?.sheet) {
+ return;
+ }
+
+ try {
+ const sheet = await sheetServiceClientConnect.getSheet({
+ name: rev.sheet,
+ raw: true,
+ });
+ if (!cancelled && sheet.content) {
+ setStatement(new TextDecoder().decode(sheet.content));
+ }
+ } catch (error) {
+ console.error("Failed to fetch sheet content", error);
+ }
+ })
+ .catch((error) => {
+ console.error("Failed to fetch revision details", error);
+ })
+ .finally(() => {
+ if (!cancelled) {
+ setLoading(false);
+ }
+ });
+
+ return () => {
+ cancelled = true;
+ };
+ }, [revisionName, revisionStore]);
+
+ const taskFullLink = revision?.taskRun
+ ? extractTaskLink(revision.taskRun)
+ : "";
+ const formattedCreateTime = revision
+ ? formatAbsoluteDateTime(getTimeForPbTimestampProtoEs(revision.createTime))
+ : "";
+ const formattedStatementSize = statement
+ ? bytesToString(new TextEncoder().encode(statement).length)
+ : "";
+
+ const handleTaskFullLinkClick = (event: MouseEvent<HTMLAnchorElement>) => {
+ if (
+ event.button !== 0 ||
+ event.metaKey ||
+ event.altKey ||
+ event.ctrlKey ||
+ event.shiftKey
+ ) {
+ return;
+ }
+ event.preventDefault();
+ router.push({ path: taskFullLink });
+ };
+
+ if (loading) {
+ return (
+ <div className="flex items-center justify-center py-2 text-sm text-gray-400">
+ <LoaderCircle className="h-4 w-4 animate-spin" />
+ </div>
+ );
+ }
+
+ if (!revision) {
+ return null;
+ }
+
+ return (
+ <div className="focus:outline-hidden" tabIndex={0}>
+ <main className="relative flex flex-col gap-y-6">
+ <div className="flex flex-col gap-y-4">
+ <h2 className="text-2xl font-semibold text-main">
+ {revision.version}
+ </h2>
+ <div className="flex items-center gap-x-3 text-sm text-control-light">
+ <span>{getRevisionType(revision.type)}</span>
+ {formattedCreateTime ? <span aria-hidden="true">•</span> : null}
+ {formattedCreateTime ? <span>{formattedCreateTime}</span> : null}
+ </div>
+ </div>
+
+ <div className="flex flex-col gap-y-6">
+ {revision.taskRun ? (
+ <div className="flex flex-col gap-y-2">
+ <div className="flex items-center justify-between">
+ <p className="text-lg text-main">{t("issue.task-run.logs")}</p>
+ {taskFullLink ? (
+ <a
+ href={taskFullLink}
+ className="flex items-center gap-x-1 text-sm text-control-light transition-colors hover:text-accent"
+ onClick={handleTaskFullLinkClick}
+ >
+ {t("common.show-more")}
+ <ArrowUpRight className="h-4 w-4" />
+ </a>
+ ) : null}
+ </div>
+ <TaskRunLogViewer taskRunName={revision.taskRun} />
+ </div>
+ ) : null}
+
+ <div className="flex flex-col gap-y-2">
+ <p className="flex items-center gap-x-2 text-lg text-main">
+ {t("common.statement")}
+ {formattedStatementSize ? (
+ <span className="text-sm font-normal text-control-light">
+ ({formattedStatementSize})
+ </span>
+ ) : null}
+ <CopyButton content={statement} />
+ </p>
+ <ReadonlyMonaco
+ content={statement}
+ className="relative h-auto max-h-[600px] min-h-[120px]"
+ />
+ </div>
+ </div>
+ </main>
+ </div>
+ );
+}
+
+export default RevisionDetailPanel;
diff --git a/frontend/src/react/components/revision/index.ts b/frontend/src/react/components/revision/index.ts
new file mode 100644
index 0000000000..361bb83b8c
--- /dev/null
+++ b/frontend/src/react/components/revision/index.ts
@@ -0,0 +1 @@
+export { RevisionDetailPanel } from "./RevisionDetailPanel";
diff --git a/frontend/src/react/components/task-run-log/SectionContent.tsx b/frontend/src/react/components/task-run-log/SectionContent.tsx
new file mode 100644
index 0000000000..8aa8ae05c1
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/SectionContent.tsx
@@ -0,0 +1,99 @@
+import { useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import { cn } from "@/react/lib/utils";
+import type { Section } from "./types";
+
+const ITEM_HEIGHT = 20;
+const MAX_VISIBLE_ITEMS = 10;
+const MAX_RENDERED_ITEMS = 50;
+
+export interface SectionContentProps {
+ section: Section;
+ indent?: boolean;
+ datasetKey?: string;
+}
+
+export function SectionContent({
+ section,
+ indent = false,
+ datasetKey,
+}: SectionContentProps) {
+ const { t } = useTranslation();
+ const [showAllItems, setShowAllItems] = useState(false);
+
+ useEffect(() => {
+ setShowAllItems(false);
+ }, [datasetKey, section.id]);
+
+ const visibleItems =
+ showAllItems || section.items.length <= MAX_RENDERED_ITEMS
+ ? section.items
+ : section.items.slice(0, MAX_RENDERED_ITEMS);
+ const hiddenItemCount = section.items.length - visibleItems.length;
+
+ return (
+ <div
+ className="bg-gray-50 border-t border-gray-100 overflow-auto"
+ style={{ maxHeight: `${MAX_VISIBLE_ITEMS * ITEM_HEIGHT}px` }}
+ >
+ {visibleItems.map((item, index) => (
+ <div
+ key={item.key}
+ className={cn(
+ "flex items-start gap-x-2 py-0.5 hover:bg-gray-100",
+ indent ? "px-6" : "px-3",
+ index > 0 && "border-t border-gray-100"
+ )}
+ >
+ <span className="w-6 shrink-0 text-right tabular-nums text-gray-300">
+ {index + 1}
+ </span>
+ <span className="shrink-0 tabular-nums text-gray-400">
+ {item.time}
+ </span>
+ {item.relativeTime ? (
+ <span className="shrink-0 tabular-nums text-gray-300">
+ {item.relativeTime}
+ </span>
+ ) : null}
+ <span className={cn("shrink-0", item.levelClass)}>
+ {item.levelIndicator}
+ </span>
+ <span className={cn("break-all", item.detailClass)}>
+ {item.detail}
+ </span>
+ <span className="ml-auto flex shrink-0 items-center gap-x-2">
+ {item.duration ? (
+ <span className="tabular-nums text-blue-500">
+ {item.duration}
+ </span>
+ ) : null}
+ {item.affectedRows !== undefined ? (
+ <span className="text-gray-400">
+ {item.affectedRows} {t("task.affected-rows")}
+ </span>
+ ) : null}
+ </span>
+ </div>
+ ))}
+ {hiddenItemCount > 0 ? (
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ className={cn(
+ "flex w-full items-center justify-center gap-x-2 rounded-none border-t border-gray-100 px-3 py-1.5 text-gray-500 hover:bg-gray-100 hover:text-gray-700",
+ indent ? "px-6" : "px-3"
+ )}
+ onClick={() => setShowAllItems(true)}
+ >
+ <span>{t("common.load-more")}</span>
+ <span className="tabular-nums">({hiddenItemCount})</span>
+ </Button>
+ ) : null}
+ </div>
+ );
+}
+
+export default SectionContent;
diff --git a/frontend/src/react/components/task-run-log/SectionHeader.tsx b/frontend/src/react/components/task-run-log/SectionHeader.tsx
new file mode 100644
index 0000000000..0b9f63857c
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/SectionHeader.tsx
@@ -0,0 +1,60 @@
+import { ChevronDown, ChevronRight } from "lucide-react";
+import type { ButtonHTMLAttributes } from "react";
+import { cn } from "@/react/lib/utils";
+import type { Section } from "./types";
+
+export interface SectionHeaderProps
+ extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> {
+ section: Section;
+ isExpanded: boolean;
+ indent?: boolean;
+ onToggle: () => void;
+}
+
+export function SectionHeader({
+ section,
+ isExpanded,
+ indent = false,
+ onToggle,
+ className,
+ ...props
+}: SectionHeaderProps) {
+ const StatusIcon = section.statusIcon;
+
+ return (
+ <button
+ type="button"
+ aria-expanded={isExpanded}
+ className={cn(
+ "flex w-full items-center gap-x-2 py-1.5 bg-white hover:bg-gray-50 cursor-pointer select-none text-left focus:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2",
+ indent ? "px-6" : "px-3",
+ className
+ )}
+ onClick={onToggle}
+ {...props}
+ >
+ {isExpanded ? (
+ <ChevronDown className="h-3.5 w-3.5 shrink-0 text-gray-400" />
+ ) : (
+ <ChevronRight className="h-3.5 w-3.5 shrink-0 text-gray-400" />
+ )}
+ <StatusIcon
+ className={cn(
+ "h-3.5 w-3.5 shrink-0",
+ section.statusClass,
+ section.status === "running" && "animate-spin"
+ )}
+ />
+ <span className="text-gray-700">{section.label}</span>
+ {section.entryCount > 1 ? (
+ <span className="text-gray-400">({section.entryCount})</span>
+ ) : null}
+ <span className="flex-1" />
+ {section.duration ? (
+ <span className="text-gray-500 tabular-nums">{section.duration}</span>
+ ) : null}
+ </button>
+ );
+}
+
+export default SectionHeader;
diff --git a/frontend/src/react/components/task-run-log/TaskRunLogViewer.test.tsx b/frontend/src/react/components/task-run-log/TaskRunLogViewer.test.tsx
new file mode 100644
index 0000000000..41a512de37
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/TaskRunLogViewer.test.tsx
@@ -0,0 +1,345 @@
+import { CheckCircle2 } from "lucide-react";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { TaskRunLogEntry_Type } from "@/types/proto-es/v1/rollout_service_pb";
+import { SectionContent } from "./SectionContent";
+import { TaskRunLogViewer } from "./TaskRunLogViewer";
+import type { Section } from "./types";
+import type { UseTaskRunLogSectionsOptions } from "./useTaskRunLogSections";
+
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const mocks = vi.hoisted(() => ({
+ useTaskRunLogData: vi.fn(),
+ useTaskRunLogSections: vi.fn(),
+}));
+
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({
+ t: (key: string, options?: Record<string, unknown> | number | string) => {
+ if (key === "task-run.log-viewer.summary" && options) {
+ const summary =
+ typeof options === "object"
+ ? options
+ : { sections: options, entries: "" };
+ return `${summary.sections} sections · ${summary.entries} entries`;
+ }
+ if (key === "task-run.log-detail.completed") {
+ return "Completed";
+ }
+ if (key === "task-run.log-detail.dumping") {
+ return "Dumping...";
+ }
+ if (key === "task-run.log-detail.syncing") {
+ return "Syncing...";
+ }
+ if (key === "task-run.log-detail.backup-completed" && options) {
+ const { count } = options as { count?: number };
+ return `Completed (${count} tables)`;
+ }
+ if (key === "task-run.log-detail.backing-up") {
+ return "Backing up...";
+ }
+ if (key === "task-run.log-detail.retry-attempt" && options) {
+ const { current, max } = options as {
+ current?: number;
+ max?: number;
+ };
+ return `Attempt ${current}/${max}`;
+ }
+ if (key === "task-run.log-detail.computing") {
+ return "Computing...";
+ }
+ return key;
+ },
+ }),
+}));
+
+vi.mock("./useTaskRunLogData", () => ({
+ useTaskRunLogData: mocks.useTaskRunLogData,
+}));
+
+vi.mock("./useTaskRunLogSections", () => ({
+ useTaskRunLogSections: mocks.useTaskRunLogSections,
+}));
+
+const createDefaultData = () => ({
+ entries: [],
+ sheet: undefined,
+ sheetsMap: new Map(),
+ metadataFetch: { status: "success" },
+ logFetch: { status: "success" },
+ sheetFetch: { status: "success", source: "sheet" },
+});
+
+const createDefaultSections = () => ({
+ sections: [
+ {
+ id: "section-0",
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ label: "Command Execute",
+ status: "success",
+ statusIcon: CheckCircle2,
+ statusClass: "text-green-600",
+ duration: "2s",
+ entryCount: 1,
+ items: [
+ {
+ key: "item-0",
+ time: "12:00:00.000",
+ relativeTime: "",
+ levelIndicator: "✓",
+ levelClass: "text-green-600",
+ detail: "SELECT 1;",
+ detailClass: "text-gray-600",
+ affectedRows: 2,
+ duration: "1ms",
+ },
+ ],
+ },
+ ],
+ hasMultipleReplicas: false,
+ hasReleaseFiles: false,
+ releaseFileGroups: [],
+ replicaGroups: [],
+ toggleSection: vi.fn(),
+ toggleReplica: vi.fn(),
+ toggleReleaseFile: vi.fn(),
+ isSectionExpanded: () => true,
+ isReplicaExpanded: () => true,
+ isReleaseFileExpanded: () => true,
+ expandAll: vi.fn(),
+ collapseAll: vi.fn(),
+ areAllExpanded: true,
+ totalSections: 1,
+ totalEntries: 1,
+ totalDuration: "2s",
+});
+
+const renderIntoContainer = (element: ReturnType<typeof createElement>) => {
+ const container = document.createElement("div");
+ const root = createRoot(container);
+
+ act(() => {
+ root.render(element);
+ });
+
+ return {
+ container,
+ root,
+ unmount: () =>
+ act(() => {
+ root.unmount();
+ }),
+ };
+};
+
+beforeEach(() => {
+ mocks.useTaskRunLogData.mockReturnValue(createDefaultData());
+ mocks.useTaskRunLogSections.mockReturnValue(createDefaultSections());
+});
+
+describe("TaskRunLogViewer", () => {
+ test("renders the summary and section content", () => {
+ const { container, unmount } = renderIntoContainer(
+ createElement(TaskRunLogViewer, { taskRunName: "runs/1" })
+ );
+
+ expect(container.textContent).toContain("1 sections · 1 entries");
+ expect(container.textContent).toContain("Command Execute");
+ expect(container.textContent).toContain("SELECT 1;");
+
+ unmount();
+ });
+
+ test("passes localized detail text into the section builder", () => {
+ let capturedOptions: UseTaskRunLogSectionsOptions | undefined;
+
+ mocks.useTaskRunLogSections.mockImplementation(
+ (options: UseTaskRunLogSectionsOptions) => {
+ capturedOptions = options;
+ return createDefaultSections();
+ }
+ );
+
+ const { unmount } = renderIntoContainer(
+ createElement(TaskRunLogViewer, { taskRunName: "runs/1" })
+ );
+
+ expect(capturedOptions?.detailText?.completed).toBe("Completed");
+ expect(capturedOptions?.detailText?.backingUp).toBe("Backing up...");
+ expect(
+ capturedOptions?.detailText?.runningByType?.[
+ TaskRunLogEntry_Type.SCHEMA_DUMP
+ ]
+ ).toBe("Dumping...");
+ expect(capturedOptions?.detailText?.backupCompleted?.(3)).toBe(
+ "Completed (3 tables)"
+ );
+ expect(capturedOptions?.detailText?.retryAttempt?.(2, 5)).toBe(
+ "Attempt 2/5"
+ );
+
+ unmount();
+ });
+
+ test("renders orphan release-file sections before labeled file headers", () => {
+ mocks.useTaskRunLogSections.mockReturnValue({
+ sections: [],
+ hasMultipleReplicas: false,
+ hasReleaseFiles: true,
+ releaseFileGroups: [
+ {
+ id: "orphan",
+ version: "",
+ filePath: "",
+ isOrphan: true,
+ sections: [
+ {
+ id: "orphan-section",
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ label: "Orphan Command",
+ status: "success",
+ statusIcon: CheckCircle2,
+ statusClass: "text-green-600",
+ duration: "",
+ entryCount: 1,
+ items: [
+ {
+ key: "orphan-item",
+ time: "12:00:00.000",
+ relativeTime: "",
+ levelIndicator: "✓",
+ levelClass: "text-green-600",
+ detail: "ORPHAN SELECT",
+ detailClass: "text-gray-600",
+ },
+ ],
+ },
+ ],
+ },
+ {
+ id: "file-0",
+ version: "v1",
+ filePath: "001.sql",
+ sections: [
+ {
+ id: "file-section",
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ label: "Release Command",
+ status: "success",
+ statusIcon: CheckCircle2,
+ statusClass: "text-green-600",
+ duration: "",
+ entryCount: 1,
+ items: [
+ {
+ key: "file-item",
+ time: "12:00:01.000",
+ relativeTime: "",
+ levelIndicator: "✓",
+ levelClass: "text-green-600",
+ detail: "RELEASE SELECT",
+ detailClass: "text-gray-600",
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ replicaGroups: [],
+ toggleSection: vi.fn(),
+ toggleReplica: vi.fn(),
+ toggleReleaseFile: vi.fn(),
+ isSectionExpanded: () => true,
+ isReplicaExpanded: () => true,
+ isReleaseFileExpanded: () => true,
+ expandAll: vi.fn(),
+ collapseAll: vi.fn(),
+ areAllExpanded: true,
+ totalSections: 2,
+ totalEntries: 2,
+ totalDuration: "",
+ });
+
+ const { container, unmount } = renderIntoContainer(
+ createElement(TaskRunLogViewer, { taskRunName: "runs/1" })
+ );
+
+ expect(container.textContent).toContain("ORPHAN SELECT");
+ expect(container.textContent).toContain("v1: 001.sql");
+ expect(container.textContent?.indexOf("ORPHAN SELECT") ?? -1).toBeLessThan(
+ container.textContent?.indexOf("v1: 001.sql") ?? -1
+ );
+
+ const buttonTexts = Array.from(container.querySelectorAll("button")).map(
+ (button) => button.textContent?.trim() ?? ""
+ );
+ expect(buttonTexts).not.toContain("");
+
+ unmount();
+ });
+
+ test("renders a load more action for large sections", () => {
+ const largeSection: Section = {
+ id: "section-0",
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ label: "Command Execute",
+ status: "success",
+ statusIcon: CheckCircle2,
+ statusClass: "text-green-600",
+ duration: "2s",
+ entryCount: 60,
+ items: Array.from({ length: 60 }, (_, index) => ({
+ key: `item-${index}`,
+ time: `12:00:${String(index).padStart(2, "0")}.000`,
+ relativeTime: "",
+ levelIndicator: "✓",
+ levelClass: "text-green-600",
+ detail: `ROW ${index}`,
+ detailClass: "text-gray-600",
+ })),
+ };
+
+ const { container, root, unmount } = renderIntoContainer(
+ createElement(SectionContent, {
+ section: largeSection,
+ datasetKey: "runs/1",
+ })
+ );
+
+ expect(container.textContent).toContain("common.load-more");
+ expect(container.textContent).toContain("ROW 0");
+ expect(container.textContent).not.toContain("ROW 59");
+
+ const loadMoreButton = Array.from(
+ container.querySelectorAll("button")
+ ).find((button) => button.textContent?.includes("common.load-more"));
+ expect(loadMoreButton).toBeDefined();
+
+ act(() => {
+ loadMoreButton?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true, cancelable: true })
+ );
+ });
+
+ expect(container.textContent).toContain("ROW 59");
+
+ act(() => {
+ root.render(
+ createElement(SectionContent, {
+ section: largeSection,
+ datasetKey: "runs/2",
+ })
+ );
+ });
+
+ expect(container.textContent).toContain("common.load-more");
+ expect(container.textContent).not.toContain("ROW 59");
+
+ unmount();
+ });
+});
diff --git a/frontend/src/react/components/task-run-log/TaskRunLogViewer.tsx b/frontend/src/react/components/task-run-log/TaskRunLogViewer.tsx
new file mode 100644
index 0000000000..84589afc38
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/TaskRunLogViewer.tsx
@@ -0,0 +1,285 @@
+import {
+ AlertTriangle,
+ ChevronsDownUp,
+ ChevronsUpDown,
+ FileCode,
+ List,
+ Server,
+} from "lucide-react";
+import { useCallback, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import { TaskRunLogEntry_Type } from "@/types/proto-es/v1/rollout_service_pb";
+import type { TaskRunLogDetailText } from "./model";
+import { SectionContent } from "./SectionContent";
+import { SectionHeader } from "./SectionHeader";
+import { useTaskRunLogData } from "./useTaskRunLogData";
+import { useTaskRunLogSections } from "./useTaskRunLogSections";
+
+export interface TaskRunLogViewerProps {
+ taskRunName: string;
+}
+
+export function TaskRunLogViewer({ taskRunName }: TaskRunLogViewerProps) {
+ const { t } = useTranslation();
+ const { entries, sheet, sheetsMap } = useTaskRunLogData(taskRunName);
+
+ const getSectionLabel = useCallback(
+ (type: TaskRunLogEntry_Type) => {
+ const labelMap: Partial<Record<TaskRunLogEntry_Type, string>> = {
+ [TaskRunLogEntry_Type.SCHEMA_DUMP]: t("task-run.log-type.schema-dump"),
+ [TaskRunLogEntry_Type.COMMAND_EXECUTE]: t(
+ "task-run.log-type.command-execute"
+ ),
+ [TaskRunLogEntry_Type.DATABASE_SYNC]: t(
+ "task-run.log-type.database-sync"
+ ),
+ [TaskRunLogEntry_Type.TRANSACTION_CONTROL]: t(
+ "task-run.log-type.transaction"
+ ),
+ [TaskRunLogEntry_Type.PRIOR_BACKUP]: t(
+ "task-run.log-type.prior-backup"
+ ),
+ [TaskRunLogEntry_Type.RETRY_INFO]: t("task-run.log-type.retry"),
+ [TaskRunLogEntry_Type.COMPUTE_DIFF]: t(
+ "task-run.log-type.compute-diff"
+ ),
+ [TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE]: t(
+ "task-run.log-type.release-file-execute"
+ ),
+ };
+ return labelMap[type] ?? t("common.unknown");
+ },
+ [t]
+ );
+
+ const detailText = useMemo<TaskRunLogDetailText>(
+ () => ({
+ completed: t("task-run.log-detail.completed"),
+ backingUp: t("task-run.log-detail.backing-up"),
+ runningByType: {
+ [TaskRunLogEntry_Type.SCHEMA_DUMP]: t("task-run.log-detail.dumping"),
+ [TaskRunLogEntry_Type.DATABASE_SYNC]: t("task-run.log-detail.syncing"),
+ [TaskRunLogEntry_Type.COMPUTE_DIFF]: t("task-run.log-detail.computing"),
+ },
+ backupCompleted: (count: number) =>
+ t("task-run.log-detail.backup-completed", { count }),
+ retryAttempt: (current: number, max: number) =>
+ t("task-run.log-detail.retry-attempt", { current, max }),
+ }),
+ [t]
+ );
+
+ const {
+ sections,
+ hasMultipleReplicas,
+ hasReleaseFiles,
+ releaseFileGroups,
+ replicaGroups,
+ toggleSection,
+ toggleReplica,
+ toggleReleaseFile,
+ isSectionExpanded,
+ isReplicaExpanded,
+ isReleaseFileExpanded,
+ expandAll,
+ collapseAll,
+ areAllExpanded,
+ totalSections,
+ totalEntries,
+ totalDuration,
+ } = useTaskRunLogSections({
+ entries,
+ sheet,
+ sheetsMap,
+ getSectionLabel,
+ detailText,
+ datasetKey: taskRunName,
+ });
+
+ const hasRenderableReleaseFiles =
+ hasReleaseFiles && releaseFileGroups.length > 0;
+ const hasContent =
+ sections.length > 0 || hasMultipleReplicas || hasRenderableReleaseFiles;
+
+ if (!taskRunName) {
+ return null;
+ }
+
+ if (!hasContent) {
+ return null;
+ }
+
+ const toggleExpandAll = () => {
+ if (areAllExpanded) {
+ collapseAll();
+ return;
+ }
+ expandAll();
+ };
+
+ const renderSection = (
+ section: (typeof sections)[number],
+ indent = false
+ ) => (
+ <div key={section.id} className="border-b border-gray-200 last:border-b-0">
+ <SectionHeader
+ section={section}
+ indent={indent}
+ isExpanded={isSectionExpanded(section.id)}
+ onToggle={() => toggleSection(section.id)}
+ />
+ {isSectionExpanded(section.id) ? (
+ <SectionContent
+ section={section}
+ indent={indent}
+ datasetKey={taskRunName}
+ />
+ ) : null}
+ </div>
+ );
+
+ const renderReleaseFileGroup = (
+ fileGroup: (typeof releaseFileGroups)[number],
+ indent = false
+ ) => {
+ if (fileGroup.isOrphan) {
+ return (
+ <div key={fileGroup.id}>
+ {fileGroup.sections.map((section) => renderSection(section, indent))}
+ </div>
+ );
+ }
+
+ return (
+ <div
+ key={fileGroup.id}
+ className="border-b border-gray-200 last:border-b-0"
+ >
+ <div className={indent ? "pl-4" : ""}>
+ <button
+ type="button"
+ className="flex w-full select-none items-center gap-x-2 bg-blue-50 px-3 py-1.5 text-left hover:bg-blue-100"
+ onClick={() => toggleReleaseFile(fileGroup.id)}
+ >
+ {isReleaseFileExpanded(fileGroup.id) ? (
+ <ChevronsDownUp className="h-3.5 w-3.5 shrink-0 text-blue-500" />
+ ) : (
+ <ChevronsUpDown className="h-3.5 w-3.5 shrink-0 text-blue-500" />
+ )}
+ <FileCode className="h-3.5 w-3.5 shrink-0 text-blue-500" />
+ <span className="font-medium text-blue-700">
+ {fileGroup.filePath
+ ? `${fileGroup.version}: ${fileGroup.filePath}`
+ : fileGroup.version}
+ </span>
+ </button>
+ {isReleaseFileExpanded(fileGroup.id) ? (
+ <div className={indent ? "pl-4" : ""}>
+ {fileGroup.sections.map((section) =>
+ renderSection(section, true)
+ )}
+ </div>
+ ) : null}
+ </div>
+ </div>
+ );
+ };
+
+ const content = hasMultipleReplicas ? (
+ <>
+ <div className="flex items-center gap-x-2 px-3 py-2 bg-amber-50 border-b border-amber-200 text-amber-800">
+ <AlertTriangle className="h-4 w-4 shrink-0" />
+ <span>{t("task-run.log-viewer.multiple-replicas-notice")}</span>
+ </div>
+ {replicaGroups.map((replicaGroup, replicaIdx) => (
+ <div
+ key={replicaGroup.replicaId}
+ className="border-b border-gray-300 last:border-b-0"
+ >
+ <button
+ type="button"
+ className="flex w-full select-none items-center gap-x-2 bg-gray-100 px-3 py-1.5 text-left hover:bg-gray-200"
+ onClick={() => toggleReplica(replicaGroup.replicaId)}
+ >
+ {isReplicaExpanded(replicaGroup.replicaId) ? (
+ <ChevronsDownUp className="h-3.5 w-3.5 shrink-0 text-gray-500" />
+ ) : (
+ <ChevronsUpDown className="h-3.5 w-3.5 shrink-0 text-gray-500" />
+ )}
+ <Server className="h-3.5 w-3.5 shrink-0 text-gray-500" />
+ <span className="font-medium text-gray-700">
+ {t("task-run.log-viewer.replica-n", { n: replicaIdx + 1 })}
+ </span>
+ <span className="text-[10px] font-normal text-gray-400">
+ {replicaGroup.replicaId.substring(0, 8)}
+ </span>
+ </button>
+
+ {isReplicaExpanded(replicaGroup.replicaId) ? (
+ <div>
+ {replicaGroup.sections.map((section) =>
+ renderSection(section, true)
+ )}
+ {replicaGroup.releaseFileGroups.map((fileGroup) =>
+ renderReleaseFileGroup(fileGroup, true)
+ )}
+ </div>
+ ) : null}
+ </div>
+ ))}
+ </>
+ ) : hasRenderableReleaseFiles ? (
+ <>
+ {releaseFileGroups.map((fileGroup) => renderReleaseFileGroup(fileGroup))}
+ </>
+ ) : (
+ <>{sections.map((section) => renderSection(section))}</>
+ );
+
+ return (
+ <div className="w-full font-mono text-xs">
+ {hasContent ? (
+ <div className="w-full overflow-hidden rounded border border-gray-200 bg-gray-50">
+ <div className="flex items-center justify-between border-b border-gray-200 bg-gray-100 px-2 py-1">
+ <div className="flex items-center gap-x-2 text-gray-500">
+ <List className="h-3.5 w-3.5" />
+ <span>
+ {t("task-run.log-viewer.summary", {
+ sections: totalSections,
+ entries: totalEntries,
+ })}
+ </span>
+ {totalDuration ? (
+ <span className="tabular-nums text-blue-500">
+ {totalDuration}
+ </span>
+ ) : null}
+ </div>
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ className="h-7 gap-x-1 px-2 text-xs text-gray-600 hover:text-gray-900"
+ onClick={toggleExpandAll}
+ >
+ {areAllExpanded ? (
+ <ChevronsDownUp className="h-3.5 w-3.5" />
+ ) : (
+ <ChevronsUpDown className="h-3.5 w-3.5" />
+ )}
+ <span>
+ {areAllExpanded
+ ? t("task-run.log-viewer.collapse-all")
+ : t("task-run.log-viewer.expand-all")}
+ </span>
+ </Button>
+ </div>
+ {content}
+ </div>
+ ) : null}
+ </div>
+ );
+}
+
+export default TaskRunLogViewer;
diff --git a/frontend/src/react/components/task-run-log/index.ts b/frontend/src/react/components/task-run-log/index.ts
new file mode 100644
index 0000000000..0f7880258e
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/index.ts
@@ -0,0 +1,2 @@
+export { TaskRunLogViewer } from "./TaskRunLogViewer";
+export * from "./types";
diff --git a/frontend/src/react/components/task-run-log/model.test.ts b/frontend/src/react/components/task-run-log/model.test.ts
new file mode 100644
index 0000000000..464f7f644d
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/model.test.ts
@@ -0,0 +1,456 @@
+import { create } from "@bufbuild/protobuf";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, expect, test, vi } from "vitest";
+import {
+ type TaskRunLogEntry,
+ TaskRunLogEntry_PriorBackup_PriorBackupDetail_ItemSchema,
+ TaskRunLogEntry_Type,
+ TaskRunLogEntrySchema,
+} from "@/types/proto-es/v1/rollout_service_pb";
+import type { Sheet } from "@/types/proto-es/v1/sheet_service_pb";
+import {
+ buildReleaseFileGroups,
+ buildSectionsFromEntries,
+ groupEntriesByReleaseFile,
+ hasReleaseFileMarkers,
+ type TaskRunLogDetailText,
+} from "./model";
+import {
+ buildReleaseSheetFetchResult,
+ buildSheetFetchStateForMissingTask,
+ getUnresolvedTaskMetadataStateKey,
+} from "./useTaskRunLogData";
+import {
+ type UseTaskRunLogSectionsResult,
+ useTaskRunLogSections,
+} from "./useTaskRunLogSections";
+
+vi.mock("@/connect", () => ({
+ rolloutServiceClientConnect: {},
+ sheetServiceClientConnect: {},
+}));
+
+vi.mock("@/react/hooks/useVueState", () => ({
+ useVueState: () => undefined,
+}));
+
+vi.mock("@/store", () => ({
+ useReleaseStore: () => ({}),
+ useRolloutStore: () => ({}),
+}));
+
+vi.mock("@/utils", () => ({
+ extractRolloutNameFromTaskRunName: () => "",
+ extractTaskNameFromTaskRunName: () => "",
+ isReleaseBasedTask: () => false,
+ releaseNameOfTaskV1: () => "",
+ sheetNameOfTaskV1: () => "",
+}));
+
+const ts = (seconds: number) => ({ seconds: BigInt(seconds), nanos: 0 });
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+interface HookHarnessProps {
+ entries: TaskRunLogEntry[];
+ datasetKey?: string;
+}
+
+const createHookHarness = (initialProps: HookHarnessProps) => {
+ const container = document.createElement("div");
+ const root = createRoot(container);
+ let current: UseTaskRunLogSectionsResult | undefined;
+
+ const Harness = (props: HookHarnessProps) => {
+ current = useTaskRunLogSections({
+ entries: props.entries,
+ datasetKey: props.datasetKey,
+ getSectionLabel: (type) => String(type),
+ });
+ return null;
+ };
+
+ const render = (props: HookHarnessProps) => {
+ act(() => {
+ root.render(createElement(Harness, props));
+ });
+ };
+
+ const getCurrent = () => {
+ if (!current) {
+ throw new Error("hook result is unavailable");
+ }
+ return current;
+ };
+
+ render(initialProps);
+
+ return {
+ render,
+ getCurrent,
+ unmount: () =>
+ act(() => {
+ root.unmount();
+ }),
+ };
+};
+
+describe("task-run-log model", () => {
+ test("keeps unresolved task sheet state non-error while metadata is pending", () => {
+ const metadataIdleState = buildSheetFetchStateForMissingTask(
+ "tasks/run-1",
+ {
+ status: "idle",
+ }
+ );
+ expect(metadataIdleState).toMatchObject({
+ status: "loading",
+ source: "none",
+ });
+
+ const unresolvedTaskState = buildSheetFetchStateForMissingTask(
+ "tasks/run-1",
+ {
+ status: "success",
+ }
+ );
+ expect(unresolvedTaskState).toMatchObject({
+ status: "error",
+ source: "none",
+ error: "Task cannot be resolved from rollout metadata",
+ });
+
+ const metadataLoadingState = buildSheetFetchStateForMissingTask(
+ "tasks/run-1",
+ {
+ status: "loading",
+ }
+ );
+ expect(metadataLoadingState).toMatchObject({
+ status: "loading",
+ source: "none",
+ });
+ });
+
+ test("ignores metadata transitions for resolved task fetch dependencies", () => {
+ const loadingKey = getUnresolvedTaskMetadataStateKey(true, {
+ status: "loading",
+ });
+ const successKey = getUnresolvedTaskMetadataStateKey(true, {
+ status: "success",
+ });
+ const errorKey = getUnresolvedTaskMetadataStateKey(true, {
+ status: "error",
+ error: "boom",
+ });
+
+ expect(loadingKey).toBe("resolved");
+ expect(successKey).toBe("resolved");
+ expect(errorKey).toBe("resolved");
+ });
+
+ test("marks release sheet fetch as partial when some versions fail", () => {
+ const result = buildReleaseSheetFetchResult([
+ { version: "v1", sheet: {} as Sheet },
+ { version: "v2" },
+ ]);
+
+ expect(result.sheetsMap.size).toBe(1);
+ expect(result.sheetsMap.has("v1")).toBe(true);
+ expect(result.state).toMatchObject({
+ status: "partial",
+ source: "release",
+ failedReleaseVersions: ["v2"],
+ });
+ });
+
+ test("groups release-file entries by version marker", () => {
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(1),
+ releaseFileExecute: { version: "v1", filePath: "001.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(2),
+ commandExecute: {
+ statement: "ALTER TABLE book ADD COLUMN title TEXT;",
+ response: { logTime: ts(3) },
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(4),
+ commandExecute: {
+ statement: "ALTER TABLE book ADD COLUMN author TEXT;",
+ response: { logTime: ts(5) },
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(6),
+ releaseFileExecute: { version: "v2", filePath: "002.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(7),
+ commandExecute: {
+ statement: "CREATE INDEX idx_book_author ON book(author);",
+ response: { logTime: ts(8) },
+ },
+ }),
+ ];
+
+ expect(hasReleaseFileMarkers(entries)).toBe(true);
+ const groups = buildReleaseFileGroups(entries);
+ expect(groups).toHaveLength(2);
+ expect(groups[0]).toMatchObject({
+ id: "file-0",
+ version: "v1",
+ filePath: "001.sql",
+ sections: [{ entryCount: 2 }],
+ });
+ expect(groups[1]).toMatchObject({
+ id: "file-1",
+ version: "v2",
+ filePath: "002.sql",
+ sections: [{ entryCount: 1 }],
+ });
+ });
+
+ test("marks incomplete sections as running and errored sections as error", () => {
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(10),
+ commandExecute: { statement: "SELECT 1;" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.TRANSACTION_CONTROL,
+ logTime: ts(11),
+ transactionControl: { error: "rollback failed" },
+ }),
+ ];
+
+ const sections = buildSectionsFromEntries(entries, {
+ getSectionLabel: (type) => String(type),
+ });
+
+ expect(sections[0]?.status).toBe("running");
+ expect(sections[1]?.status).toBe("error");
+ });
+
+ test("uses localized detail text for completed timed entries, prior backup completion, and retries", () => {
+ const detailText = {
+ completed: "Completed",
+ backingUp: "Backing up...",
+ runningByType: {
+ [TaskRunLogEntry_Type.SCHEMA_DUMP]: "Dumping...",
+ },
+ backupCompleted: (count: number) => `Completed (${count} tables)`,
+ retryAttempt: (current: number, max: number) =>
+ `Attempt ${current}/${max}`,
+ } satisfies TaskRunLogDetailText;
+
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.SCHEMA_DUMP,
+ logTime: ts(1),
+ schemaDump: {
+ startTime: ts(1),
+ endTime: ts(2),
+ error: "",
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.PRIOR_BACKUP,
+ logTime: ts(3),
+ priorBackup: {
+ startTime: ts(3),
+ endTime: ts(4),
+ priorBackupDetail: {
+ items: [
+ create(
+ TaskRunLogEntry_PriorBackup_PriorBackupDetail_ItemSchema,
+ {}
+ ),
+ create(
+ TaskRunLogEntry_PriorBackup_PriorBackupDetail_ItemSchema,
+ {}
+ ),
+ ],
+ },
+ error: "",
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RETRY_INFO,
+ logTime: ts(5),
+ retryInfo: {
+ error: "",
+ retryCount: 2,
+ maximumRetries: 5,
+ },
+ }),
+ ];
+
+ const sections = buildSectionsFromEntries(entries, {
+ getSectionLabel: (type) => String(type),
+ detailText,
+ });
+
+ expect(sections[0]?.items[0]?.detail).toBe("Completed");
+ expect(sections[1]?.items[0]?.detail).toBe("Completed (2 tables)");
+ expect(sections[2]?.items[0]?.detail).toBe("Attempt 2/5");
+ });
+
+ test("drops empty release-file groups created by consecutive and trailing markers", () => {
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(1),
+ commandExecute: {
+ statement: "SELECT 1;",
+ response: { logTime: ts(2) },
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(3),
+ releaseFileExecute: { version: "v1", filePath: "001.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(4),
+ releaseFileExecute: { version: "v2", filePath: "002.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(5),
+ commandExecute: {
+ statement: "ALTER TABLE t ADD COLUMN c INT;",
+ response: { logTime: ts(6) },
+ },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(7),
+ releaseFileExecute: { version: "v3", filePath: "003.sql" },
+ }),
+ ];
+
+ const groupedEntries = groupEntriesByReleaseFile(entries);
+ expect(groupedEntries).toHaveLength(4);
+ expect(groupedEntries[0]).toMatchObject({ file: null });
+ expect(groupedEntries[0]?.entries).toHaveLength(1);
+ expect(groupedEntries[1]).toMatchObject({
+ file: { version: "v1", filePath: "001.sql" },
+ });
+ expect(groupedEntries[1]?.entries).toHaveLength(0);
+ expect(groupedEntries[2]).toMatchObject({
+ file: { version: "v2", filePath: "002.sql" },
+ });
+ expect(groupedEntries[2]?.entries).toHaveLength(1);
+ expect(groupedEntries[3]).toMatchObject({
+ file: { version: "v3", filePath: "003.sql" },
+ });
+ expect(groupedEntries[3]?.entries).toHaveLength(0);
+
+ const groups = buildReleaseFileGroups(entries, {
+ getSectionLabel: (type) => String(type),
+ includeOrphanGroup: true,
+ });
+ expect(groups).toHaveLength(2);
+ expect(groups[0]).toMatchObject({
+ id: "orphan",
+ isOrphan: true,
+ version: "",
+ filePath: "",
+ sections: [{ entryCount: 1 }],
+ });
+ expect(groups[1]).toMatchObject({
+ id: "file-0",
+ version: "v2",
+ filePath: "002.sql",
+ sections: [{ entryCount: 1 }],
+ });
+ });
+
+ test("handles expand/collapse state for filtered release-file groups", () => {
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(1),
+ releaseFileExecute: { version: "v1", filePath: "001.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE,
+ logTime: ts(2),
+ releaseFileExecute: { version: "v2", filePath: "002.sql" },
+ }),
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(3),
+ commandExecute: {
+ statement: "SELECT 1;",
+ response: { logTime: ts(4) },
+ },
+ }),
+ ];
+
+ const hook = createHookHarness({ entries, datasetKey: "marker-only" });
+
+ expect(hook.getCurrent().releaseFileGroups).toHaveLength(1);
+ expect(
+ hook.getCurrent().releaseFileGroups.map((group) => group.id)
+ ).toEqual(["file-0"]);
+ expect(hook.getCurrent().totalSections).toBe(1);
+
+ act(() => {
+ hook.getCurrent().collapseAll();
+ });
+ expect(hook.getCurrent().areAllExpanded).toBe(false);
+
+ act(() => {
+ hook.getCurrent().expandAll();
+ });
+ expect(hook.getCurrent().areAllExpanded).toBe(true);
+
+ act(() => {
+ hook.getCurrent().toggleReleaseFile("file-0");
+ });
+ expect(hook.getCurrent().areAllExpanded).toBe(false);
+
+ hook.unmount();
+ });
+
+ test("resets expansion state when dataset key changes", () => {
+ const entries = [
+ create(TaskRunLogEntrySchema, {
+ type: TaskRunLogEntry_Type.COMMAND_EXECUTE,
+ logTime: ts(1),
+ commandExecute: {
+ statement: "SELECT 1;",
+ response: { logTime: ts(2) },
+ },
+ }),
+ ];
+
+ const hook = createHookHarness({ entries, datasetKey: "dataset-a" });
+ const sectionId = hook.getCurrent().sections[0]?.id;
+ expect(sectionId).toBe("section-0");
+
+ act(() => {
+ hook.getCurrent().toggleSection(sectionId!);
+ });
+ expect(hook.getCurrent().isSectionExpanded(sectionId!)).toBe(true);
+
+ hook.render({ entries, datasetKey: "dataset-b" });
+ expect(hook.getCurrent().isSectionExpanded(sectionId!)).toBe(false);
+
+ hook.unmount();
+ });
+});
diff --git a/frontend/src/react/components/task-run-log/model.ts b/frontend/src/react/components/task-run-log/model.ts
new file mode 100644
index 0000000000..62857cb3f8
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/model.ts
@@ -0,0 +1,590 @@
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { LucideIcon } from "lucide-react";
+import { CheckCircle2, Circle, LoaderCircle, XCircle } from "lucide-react";
+import type { TaskRunLogEntry } from "@/types/proto-es/v1/rollout_service_pb";
+import {
+ TaskRunLogEntry_TransactionControl_Type,
+ TaskRunLogEntry_Type,
+} from "@/types/proto-es/v1/rollout_service_pb";
+import type { Sheet } from "@/types/proto-es/v1/sheet_service_pb";
+import type {
+ DisplayItem,
+ EntryGroup,
+ ReleaseFileEntriesGroup,
+ ReleaseFileGroup,
+ Section,
+ SectionStatus,
+} from "./types";
+
+const STATUS_CONFIG: Record<
+ SectionStatus,
+ { icon: LucideIcon; className: string }
+> = {
+ success: { icon: CheckCircle2, className: "text-green-600" },
+ error: { icon: XCircle, className: "text-red-600" },
+ running: { icon: LoaderCircle, className: "text-blue-600" },
+ pending: { icon: Circle, className: "text-gray-400" },
+};
+
+export interface BuildSectionsOptions {
+ getSectionLabel: (type: TaskRunLogEntry_Type) => string;
+ sheet?: Sheet;
+ sheetsMap?: Map<string, Sheet>;
+ idPrefix?: string;
+ forceError?: boolean;
+ fileVersion?: string;
+ detailText?: TaskRunLogDetailText;
+}
+
+export interface BuildReleaseFileGroupsOptions {
+ getSectionLabel: (type: TaskRunLogEntry_Type) => string;
+ sheet?: Sheet;
+ sheetsMap?: Map<string, Sheet>;
+ idPrefix?: string;
+ forceError?: boolean;
+ detailText?: TaskRunLogDetailText;
+ includeOrphanGroup?: boolean;
+}
+
+export interface TaskRunLogDetailText {
+ completed?: string;
+ backingUp?: string;
+ runningByType?: Partial<Record<TaskRunLogEntry_Type, string>>;
+ transactionError?: (typeLabel: string, error: string) => string;
+ retryAttempt?: (current: number, max: number) => string;
+ backupCompleted?: (count: number) => string;
+}
+
+export const getTimestampMs = (timestamp?: Timestamp): number => {
+ if (!timestamp) return 0;
+ return Number(timestamp.seconds) * 1000 + timestamp.nanos / 1000000;
+};
+
+export const formatTime = (timestamp?: Timestamp): string => {
+ if (!timestamp) return "--:--:--.---";
+ const date = new Date(getTimestampMs(timestamp));
+ return (
+ [
+ date.getHours().toString().padStart(2, "0"),
+ date.getMinutes().toString().padStart(2, "0"),
+ date.getSeconds().toString().padStart(2, "0"),
+ ].join(":") +
+ "." +
+ date.getMilliseconds().toString().padStart(3, "0")
+ );
+};
+
+export const formatDuration = (ms: number): string => {
+ if (ms < 1) return "<1ms";
+ if (ms < 1000) return `${ms.toFixed(0)}ms`;
+ if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+ const minutes = Math.floor(ms / 60000);
+ const seconds = ((ms % 60000) / 1000).toFixed(0);
+ return `${minutes}m ${seconds}s`;
+};
+
+export const formatRelativeTime = (ms: number): string => {
+ if (ms < 1000) return `+${ms.toFixed(0)}ms`;
+ return `+${(ms / 1000).toFixed(2)}s`;
+};
+
+export const hasError = (entry: TaskRunLogEntry): boolean => {
+ switch (entry.type) {
+ case TaskRunLogEntry_Type.COMMAND_EXECUTE:
+ return Boolean(entry.commandExecute?.response?.error);
+ case TaskRunLogEntry_Type.TRANSACTION_CONTROL:
+ return Boolean(entry.transactionControl?.error);
+ case TaskRunLogEntry_Type.SCHEMA_DUMP:
+ return Boolean(entry.schemaDump?.error);
+ case TaskRunLogEntry_Type.DATABASE_SYNC:
+ return Boolean(entry.databaseSync?.error);
+ case TaskRunLogEntry_Type.PRIOR_BACKUP:
+ return Boolean(entry.priorBackup?.error);
+ case TaskRunLogEntry_Type.COMPUTE_DIFF:
+ return Boolean(entry.computeDiff?.error);
+ default:
+ return false;
+ }
+};
+
+export const isComplete = (entry: TaskRunLogEntry): boolean => {
+ switch (entry.type) {
+ case TaskRunLogEntry_Type.COMMAND_EXECUTE:
+ return Boolean(entry.commandExecute?.response);
+ case TaskRunLogEntry_Type.SCHEMA_DUMP:
+ return Boolean(entry.schemaDump?.startTime && entry.schemaDump?.endTime);
+ case TaskRunLogEntry_Type.DATABASE_SYNC:
+ return Boolean(
+ entry.databaseSync?.startTime && entry.databaseSync?.endTime
+ );
+ case TaskRunLogEntry_Type.PRIOR_BACKUP:
+ return Boolean(
+ entry.priorBackup?.startTime && entry.priorBackup?.endTime
+ );
+ case TaskRunLogEntry_Type.COMPUTE_DIFF:
+ return Boolean(
+ entry.computeDiff?.startTime && entry.computeDiff?.endTime
+ );
+ case TaskRunLogEntry_Type.TRANSACTION_CONTROL:
+ case TaskRunLogEntry_Type.RETRY_INFO:
+ return true;
+ default:
+ return true;
+ }
+};
+
+export const groupEntriesByType = (
+ entries: TaskRunLogEntry[]
+): EntryGroup[] => {
+ if (entries.length === 0) return [];
+ const sorted = [...entries].sort(
+ (a, b) => getTimestampMs(a.logTime) - getTimestampMs(b.logTime)
+ );
+ const groups: EntryGroup[] = [];
+ let current: EntryGroup | undefined;
+
+ for (const entry of sorted) {
+ if (current && current.type === entry.type) {
+ current.entries.push(entry);
+ continue;
+ }
+ current = { type: entry.type, entries: [entry] };
+ groups.push(current);
+ }
+
+ return groups;
+};
+
+export const hasReleaseFileMarkers = (entries: TaskRunLogEntry[]): boolean => {
+ return entries.some(
+ (entry) => entry.type === TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE
+ );
+};
+
+export const groupEntriesByReleaseFile = (
+ entries: TaskRunLogEntry[]
+): ReleaseFileEntriesGroup[] => {
+ if (entries.length === 0) return [];
+
+ const sorted = [...entries].sort(
+ (a, b) => getTimestampMs(a.logTime) - getTimestampMs(b.logTime)
+ );
+ const groups: ReleaseFileEntriesGroup[] = [];
+ let current: ReleaseFileEntriesGroup = { file: null, entries: [] };
+
+ for (const entry of sorted) {
+ if (entry.type === TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE) {
+ if (current.file !== null || current.entries.length > 0) {
+ groups.push(current);
+ }
+ const releaseFile = entry.releaseFileExecute;
+ current = {
+ file: releaseFile
+ ? {
+ version: releaseFile.version,
+ filePath: releaseFile.filePath || "",
+ }
+ : null,
+ entries: [],
+ };
+ continue;
+ }
+ current.entries.push(entry);
+ }
+
+ if (current.file !== null || current.entries.length > 0) {
+ groups.push(current);
+ }
+
+ return groups;
+};
+
+export const getUniqueReplicaIds = (entries: TaskRunLogEntry[]): string[] => {
+ if (entries.length === 0) return [];
+ const sorted = [...entries].sort(
+ (a, b) => getTimestampMs(a.logTime) - getTimestampMs(b.logTime)
+ );
+ const replicaIds: string[] = [];
+ const seen = new Set<string>();
+
+ for (const entry of sorted) {
+ const replicaId = entry.replicaId || "";
+ if (!replicaId || seen.has(replicaId)) continue;
+ seen.add(replicaId);
+ replicaIds.push(replicaId);
+ }
+
+ return replicaIds;
+};
+
+export const groupEntriesByReplica = (
+ entries: TaskRunLogEntry[]
+): Map<string, TaskRunLogEntry[]> => {
+ const grouped = new Map<string, TaskRunLogEntry[]>();
+
+ for (const entry of entries) {
+ const replicaId = entry.replicaId || "unknown";
+ if (!grouped.has(replicaId)) {
+ grouped.set(replicaId, []);
+ }
+ grouped.get(replicaId)!.push(entry);
+ }
+
+ return grouped;
+};
+
+export const getEntryTimeRange = (
+ entry: TaskRunLogEntry
+): { start: number; end: number } => {
+ switch (entry.type) {
+ case TaskRunLogEntry_Type.COMMAND_EXECUTE: {
+ const start = getTimestampMs(entry.commandExecute?.logTime);
+ const end = getTimestampMs(entry.commandExecute?.response?.logTime);
+ return { start: start || 0, end: end || start || 0 };
+ }
+ case TaskRunLogEntry_Type.SCHEMA_DUMP:
+ return {
+ start: getTimestampMs(entry.schemaDump?.startTime),
+ end: getTimestampMs(entry.schemaDump?.endTime),
+ };
+ case TaskRunLogEntry_Type.DATABASE_SYNC:
+ return {
+ start: getTimestampMs(entry.databaseSync?.startTime),
+ end: getTimestampMs(entry.databaseSync?.endTime),
+ };
+ case TaskRunLogEntry_Type.PRIOR_BACKUP:
+ return {
+ start: getTimestampMs(entry.priorBackup?.startTime),
+ end: getTimestampMs(entry.priorBackup?.endTime),
+ };
+ case TaskRunLogEntry_Type.COMPUTE_DIFF:
+ return {
+ start: getTimestampMs(entry.computeDiff?.startTime),
+ end: getTimestampMs(entry.computeDiff?.endTime),
+ };
+ default: {
+ const time = getTimestampMs(entry.logTime);
+ return { start: time, end: time };
+ }
+ }
+};
+
+const extractStatementFromRange = (
+ range: { start: number; end: number },
+ sheet: Sheet | undefined,
+ sheetsMap: Map<string, Sheet> | undefined,
+ fileVersion?: string
+): string | undefined => {
+ let content = sheet?.content;
+ if (fileVersion && sheetsMap) {
+ const releaseFileSheet = sheetsMap.get(fileVersion);
+ if (releaseFileSheet?.content) {
+ content = releaseFileSheet.content;
+ }
+ }
+ if (!content) return undefined;
+ const subarray = content.subarray(range.start, range.end);
+ return new TextDecoder().decode(subarray);
+};
+
+const getCommandExecuteDetail = (
+ entry: TaskRunLogEntry,
+ sheet: Sheet | undefined,
+ sheetsMap: Map<string, Sheet> | undefined,
+ fileVersion?: string
+): string => {
+ const command = entry.commandExecute;
+ if (!command) return "";
+ if (command.response?.error) return command.response.error;
+
+ const statement =
+ command.statement ||
+ (command.range
+ ? extractStatementFromRange(command.range, sheet, sheetsMap, fileVersion)
+ : undefined);
+ if (!statement) return "-";
+
+ const normalized = statement.trim().replace(/\s+/g, " ");
+ return normalized.length > 80
+ ? `${normalized.substring(0, 80)}...`
+ : normalized;
+};
+
+const getTransactionControlDetail = (
+ entry: TaskRunLogEntry,
+ detailText: TaskRunLogDetailText | undefined
+): string => {
+ const transaction = entry.transactionControl;
+ if (!transaction) return "";
+
+ const typeLabels: Record<number, string> = {
+ [TaskRunLogEntry_TransactionControl_Type.BEGIN]: "BEGIN",
+ [TaskRunLogEntry_TransactionControl_Type.COMMIT]: "COMMIT",
+ [TaskRunLogEntry_TransactionControl_Type.ROLLBACK]: "ROLLBACK",
+ };
+
+ const typeLabel = typeLabels[transaction.type] ?? "";
+ if (!transaction.error) return typeLabel;
+
+ if (detailText?.transactionError) {
+ return detailText.transactionError(typeLabel, transaction.error);
+ }
+ return typeLabel ? `${typeLabel}: ${transaction.error}` : transaction.error;
+};
+
+const getTimedEntryDetail = (
+ timedEntry:
+ | {
+ error?: string;
+ startTime?: Timestamp;
+ endTime?: Timestamp;
+ }
+ | undefined,
+ runningLabel: string,
+ completedLabel: string
+): string => {
+ if (!timedEntry) return "";
+ if (timedEntry.error) return timedEntry.error;
+ if (timedEntry.startTime && timedEntry.endTime) return completedLabel;
+ return runningLabel;
+};
+
+const getPriorBackupDetail = (
+ entry: TaskRunLogEntry,
+ detailText: TaskRunLogDetailText | undefined
+): string => {
+ const priorBackup = entry.priorBackup;
+ if (!priorBackup) return "";
+ if (priorBackup.error) return priorBackup.error;
+ const itemCount = priorBackup.priorBackupDetail?.items.length ?? 0;
+ if (itemCount > 0) {
+ if (detailText?.backupCompleted) {
+ return detailText.backupCompleted(itemCount);
+ }
+ return String(itemCount);
+ }
+ if (priorBackup.startTime && priorBackup.endTime) {
+ return detailText?.completed ?? "";
+ }
+ return detailText?.backingUp ?? "";
+};
+
+const getRetryInfoDetail = (
+ entry: TaskRunLogEntry,
+ detailText: TaskRunLogDetailText | undefined
+): string => {
+ const retryInfo = entry.retryInfo;
+ if (!retryInfo) return "";
+ const attempt = detailText?.retryAttempt
+ ? detailText.retryAttempt(retryInfo.retryCount, retryInfo.maximumRetries)
+ : `${retryInfo.retryCount}/${retryInfo.maximumRetries}`;
+ return retryInfo.error ? `${attempt}: ${retryInfo.error}` : attempt;
+};
+
+const getReleaseFileExecuteDetail = (entry: TaskRunLogEntry): string => {
+ const releaseFile = entry.releaseFileExecute;
+ if (!releaseFile) return "";
+ return releaseFile.filePath
+ ? `${releaseFile.version}: ${releaseFile.filePath}`
+ : releaseFile.version;
+};
+
+const getEntryDetail = (
+ entry: TaskRunLogEntry,
+ sheet: Sheet | undefined,
+ sheetsMap: Map<string, Sheet> | undefined,
+ detailText: TaskRunLogDetailText | undefined,
+ fileVersion?: string
+): string => {
+ const runningByType = detailText?.runningByType;
+ const completed = detailText?.completed ?? "";
+
+ switch (entry.type) {
+ case TaskRunLogEntry_Type.COMMAND_EXECUTE:
+ return getCommandExecuteDetail(entry, sheet, sheetsMap, fileVersion);
+ case TaskRunLogEntry_Type.TRANSACTION_CONTROL:
+ return getTransactionControlDetail(entry, detailText);
+ case TaskRunLogEntry_Type.SCHEMA_DUMP:
+ return getTimedEntryDetail(
+ entry.schemaDump,
+ runningByType?.[TaskRunLogEntry_Type.SCHEMA_DUMP] ?? "",
+ completed
+ );
+ case TaskRunLogEntry_Type.DATABASE_SYNC:
+ return getTimedEntryDetail(
+ entry.databaseSync,
+ runningByType?.[TaskRunLogEntry_Type.DATABASE_SYNC] ?? "",
+ completed
+ );
+ case TaskRunLogEntry_Type.PRIOR_BACKUP:
+ return getPriorBackupDetail(entry, detailText);
+ case TaskRunLogEntry_Type.RETRY_INFO:
+ return getRetryInfoDetail(entry, detailText);
+ case TaskRunLogEntry_Type.COMPUTE_DIFF:
+ return getTimedEntryDetail(
+ entry.computeDiff,
+ runningByType?.[TaskRunLogEntry_Type.COMPUTE_DIFF] ?? "",
+ completed
+ );
+ case TaskRunLogEntry_Type.RELEASE_FILE_EXECUTE:
+ return getReleaseFileExecuteDetail(entry);
+ default:
+ return "";
+ }
+};
+
+const getCommandDuration = (entry: TaskRunLogEntry): string | undefined => {
+ if (entry.type !== TaskRunLogEntry_Type.COMMAND_EXECUTE) return undefined;
+ const startMs = getTimestampMs(entry.commandExecute?.logTime);
+ const endMs = getTimestampMs(entry.commandExecute?.response?.logTime);
+ if (startMs <= 0 || endMs <= 0) return undefined;
+ return formatDuration(endMs - startMs);
+};
+
+const buildDisplayItems = (
+ entries: TaskRunLogEntry[],
+ groupIndex: number,
+ startTime: number,
+ sheet: Sheet | undefined,
+ sheetsMap: Map<string, Sheet> | undefined,
+ idPrefix: string | undefined,
+ detailText: TaskRunLogDetailText | undefined,
+ fileVersion?: string
+): DisplayItem[] => {
+ return entries.map((entry, entryIndex) => {
+ const entryTime = getTimestampMs(entry.logTime);
+ const relativeMs = startTime > 0 ? entryTime - startTime : 0;
+ const entryHasError = hasError(entry);
+
+ return {
+ key: `${idPrefix ?? "section"}-${groupIndex}-${entryIndex}`,
+ time: formatTime(entry.logTime),
+ relativeTime: relativeMs > 0 ? formatRelativeTime(relativeMs) : "",
+ levelIndicator: entryHasError ? "\u2717" : "\u2713",
+ levelClass: entryHasError ? "text-red-600" : "text-green-600",
+ detail: getEntryDetail(entry, sheet, sheetsMap, detailText, fileVersion),
+ detailClass: entryHasError ? "text-red-700" : "text-gray-600",
+ affectedRows:
+ entry.type === TaskRunLogEntry_Type.COMMAND_EXECUTE
+ ? Number(entry.commandExecute?.response?.affectedRows ?? 0) ||
+ undefined
+ : undefined,
+ duration: getCommandDuration(entry),
+ };
+ });
+};
+
+const calculateSectionStatus = (entries: TaskRunLogEntry[]): SectionStatus => {
+ if (entries.some(hasError)) return "error";
+ if (entries.every(isComplete)) return "success";
+ return "running";
+};
+
+export const buildSectionsFromEntries = (
+ entries: TaskRunLogEntry[],
+ options: BuildSectionsOptions
+): Section[] => {
+ if (entries.length === 0) return [];
+
+ return groupEntriesByType(entries).map((group, groupIndex) => {
+ let status = calculateSectionStatus(group.entries);
+ if (options.forceError && status === "running") {
+ status = "error";
+ }
+ const statusConfig = STATUS_CONFIG[status];
+
+ const timeRanges = group.entries.map(getEntryTimeRange);
+ const startTimes = timeRanges
+ .map((range) => range.start)
+ .filter((time) => time > 0);
+ const endTimes = timeRanges
+ .map((range) => range.end)
+ .filter((time) => time > 0);
+ const startTime = startTimes.length > 0 ? Math.min(...startTimes) : 0;
+ const endTime = endTimes.length > 0 ? Math.max(...endTimes) : 0;
+ const durationMs = endTime - startTime;
+
+ return {
+ id: options.idPrefix
+ ? `${options.idPrefix}-section-${groupIndex}`
+ : `section-${groupIndex}`,
+ type: group.type,
+ label: options.getSectionLabel(group.type),
+ status,
+ statusIcon: statusConfig.icon,
+ statusClass: statusConfig.className,
+ duration:
+ startTime > 0 && endTime > 0
+ ? formatDuration(Math.max(durationMs, 0))
+ : "",
+ entryCount: group.entries.length,
+ items: buildDisplayItems(
+ group.entries,
+ groupIndex,
+ startTime,
+ options.sheet,
+ options.sheetsMap,
+ options.idPrefix,
+ options.detailText,
+ options.fileVersion
+ ),
+ };
+ });
+};
+
+export const buildReleaseFileGroups = (
+ entries: TaskRunLogEntry[],
+ options?: BuildReleaseFileGroupsOptions
+): ReleaseFileGroup[] => {
+ const buildOptions: BuildReleaseFileGroupsOptions = {
+ getSectionLabel: (type) => String(type),
+ includeOrphanGroup: false,
+ ...options,
+ };
+
+ const results: ReleaseFileGroup[] = [];
+ let fileIndex = 0;
+
+ for (const group of groupEntriesByReleaseFile(entries)) {
+ if (group.file === null) {
+ if (!buildOptions.includeOrphanGroup || group.entries.length === 0) {
+ continue;
+ }
+ const orphanPrefix = buildOptions.idPrefix
+ ? `${buildOptions.idPrefix}-orphan`
+ : "orphan";
+ results.push({
+ id: orphanPrefix,
+ version: "",
+ filePath: "",
+ isOrphan: true,
+ sections: buildSectionsFromEntries(group.entries, {
+ ...buildOptions,
+ idPrefix: orphanPrefix,
+ }),
+ });
+ continue;
+ }
+
+ if (group.entries.length === 0) {
+ continue;
+ }
+
+ const filePrefix = buildOptions.idPrefix
+ ? `${buildOptions.idPrefix}-file-${fileIndex}`
+ : `file-${fileIndex}`;
+ fileIndex++;
+ results.push({
+ id: filePrefix,
+ version: group.file.version,
+ filePath: group.file.filePath,
+ sections: buildSectionsFromEntries(group.entries, {
+ ...buildOptions,
+ idPrefix: filePrefix,
+ fileVersion: group.file.version,
+ }),
+ });
+ }
+
+ return results;
+};
diff --git a/frontend/src/react/components/task-run-log/types.ts b/frontend/src/react/components/task-run-log/types.ts
new file mode 100644
index 0000000000..0e8ef30675
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/types.ts
@@ -0,0 +1,60 @@
+import type { LucideIcon } from "lucide-react";
+import type {
+ TaskRunLogEntry,
+ TaskRunLogEntry_Type,
+} from "@/types/proto-es/v1/rollout_service_pb";
+
+export type SectionStatus = "success" | "error" | "running" | "pending";
+
+export interface DisplayItem {
+ key: string;
+ time: string;
+ relativeTime: string;
+ levelIndicator: string;
+ levelClass: string;
+ detail: string;
+ detailClass: string;
+ affectedRows?: number;
+ duration?: string;
+}
+
+export interface Section {
+ id: string;
+ type: TaskRunLogEntry_Type;
+ label: string;
+ status: SectionStatus;
+ statusIcon: LucideIcon;
+ statusClass: string;
+ duration: string;
+ entryCount: number;
+ items: DisplayItem[];
+}
+
+export interface EntryGroup {
+ type: TaskRunLogEntry_Type;
+ entries: TaskRunLogEntry[];
+}
+
+export interface ReleaseFileInfo {
+ version: string;
+ filePath: string;
+}
+
+export interface ReleaseFileEntriesGroup {
+ file: ReleaseFileInfo | null;
+ entries: TaskRunLogEntry[];
+}
+
+export interface ReleaseFileGroup {
+ id: string;
+ version: string;
+ filePath: string;
+ isOrphan?: boolean;
+ sections: Section[];
+}
+
+export interface ReplicaGroup {
+ replicaId: string;
+ releaseFileGroups: ReleaseFileGroup[];
+ sections: Section[];
+}
diff --git a/frontend/src/react/components/task-run-log/useTaskRunLogData.ts b/frontend/src/react/components/task-run-log/useTaskRunLogData.ts
new file mode 100644
index 0000000000..82be42ee80
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/useTaskRunLogData.ts
@@ -0,0 +1,379 @@
+import { create } from "@bufbuild/protobuf";
+import { useEffect, useMemo, useRef, useState } from "react";
+import {
+ rolloutServiceClientConnect,
+ sheetServiceClientConnect,
+} from "@/connect";
+import { useVueState } from "@/react/hooks/useVueState";
+import { useReleaseStore, useRolloutStore } from "@/store";
+import {
+ GetTaskRunLogRequestSchema,
+ type Task,
+ type TaskRunLogEntry,
+} from "@/types/proto-es/v1/rollout_service_pb";
+import type { Sheet } from "@/types/proto-es/v1/sheet_service_pb";
+import {
+ extractRolloutNameFromTaskRunName,
+ extractTaskNameFromTaskRunName,
+ isReleaseBasedTask,
+ releaseNameOfTaskV1,
+ sheetNameOfTaskV1,
+} from "@/utils";
+
+export type FetchStatus = "idle" | "loading" | "success" | "partial" | "error";
+export type SheetSource = "none" | "sheet" | "release";
+
+export interface FetchState {
+ status: FetchStatus;
+ error?: string;
+}
+
+export interface SheetFetchState extends FetchState {
+ source: SheetSource;
+ failedReleaseVersions?: string[];
+}
+
+export interface UseTaskRunLogDataResult {
+ entries: TaskRunLogEntry[];
+ sheet: Sheet | undefined;
+ sheetsMap: Map<string, Sheet>;
+ metadataFetch: FetchState;
+ logFetch: FetchState;
+ sheetFetch: SheetFetchState;
+}
+
+interface ReleaseSheetFetchResult {
+ version: string;
+ sheet?: Sheet;
+}
+
+const TASK_RESOLUTION_ERROR = "Task cannot be resolved from rollout metadata";
+
+const getTaskFromRollout = (
+ taskRunName: string | undefined,
+ rollout: { stages: Array<{ tasks: Task[] }> } | undefined
+): Task | undefined => {
+ if (!taskRunName || !rollout) return undefined;
+
+ const taskName = extractTaskNameFromTaskRunName(taskRunName);
+ if (!taskName) return undefined;
+
+ for (const stage of rollout.stages) {
+ const task = stage.tasks.find((candidate) => candidate.name === taskName);
+ if (task) {
+ return task;
+ }
+ }
+
+ return undefined;
+};
+
+const getErrorMessage = (error: unknown): string => {
+ if (error instanceof Error) return error.message;
+ return String(error);
+};
+
+export const buildSheetFetchStateForMissingTask = (
+ taskRunName: string | undefined,
+ metadataFetchState: FetchState
+): SheetFetchState => {
+ if (!taskRunName) {
+ return { status: "idle", source: "none" };
+ }
+ if (
+ metadataFetchState.status === "idle" ||
+ metadataFetchState.status === "loading"
+ ) {
+ return { status: "loading", source: "none" };
+ }
+ if (metadataFetchState.status === "error") {
+ return {
+ status: "error",
+ source: "none",
+ error: metadataFetchState.error ?? TASK_RESOLUTION_ERROR,
+ };
+ }
+ return {
+ status: "error",
+ source: "none",
+ error: TASK_RESOLUTION_ERROR,
+ };
+};
+
+export const getUnresolvedTaskMetadataStateKey = (
+ hasResolvedTask: boolean,
+ metadataFetchState: FetchState
+): string => {
+ if (hasResolvedTask) {
+ return "resolved";
+ }
+ return `${metadataFetchState.status}:${metadataFetchState.error ?? ""}`;
+};
+
+export const buildReleaseSheetFetchResult = (
+ fileSheets: ReleaseSheetFetchResult[]
+): { sheetsMap: Map<string, Sheet>; state: SheetFetchState } => {
+ const sheetsMap = new Map<string, Sheet>();
+ const failedReleaseVersions: string[] = [];
+
+ for (const item of fileSheets) {
+ if (item.sheet) {
+ sheetsMap.set(item.version, item.sheet);
+ } else {
+ failedReleaseVersions.push(item.version);
+ }
+ }
+
+ if (failedReleaseVersions.length === 0) {
+ return {
+ sheetsMap,
+ state: { status: "success", source: "release" },
+ };
+ }
+ if (sheetsMap.size === 0) {
+ return {
+ sheetsMap,
+ state: {
+ status: "error",
+ source: "release",
+ error: "Failed to fetch all release sheets",
+ failedReleaseVersions,
+ },
+ };
+ }
+ return {
+ sheetsMap,
+ state: {
+ status: "partial",
+ source: "release",
+ error: "Failed to fetch some release sheets",
+ failedReleaseVersions,
+ },
+ };
+};
+
+export const useTaskRunLogData = (
+ taskRunName?: string
+): UseTaskRunLogDataResult => {
+ const rolloutStore = useRolloutStore();
+ const releaseStore = useReleaseStore();
+
+ const [entries, setEntries] = useState<TaskRunLogEntry[]>([]);
+ const [sheet, setSheet] = useState<Sheet | undefined>(undefined);
+ const [sheetsMap, setSheetsMap] = useState<Map<string, Sheet>>(new Map());
+ const [metadataFetchState, setMetadataFetchState] = useState<FetchState>({
+ status: "idle",
+ });
+ const [logFetchState, setLogFetchState] = useState<FetchState>({
+ status: "idle",
+ });
+ const [sheetFetchState, setSheetFetchState] = useState<SheetFetchState>({
+ status: "idle",
+ source: "none",
+ });
+ const metadataFetchVersion = useRef(0);
+ const logFetchVersion = useRef(0);
+ const sheetFetchVersion = useRef(0);
+
+ const rolloutName = useMemo(() => {
+ if (!taskRunName) return "";
+ return extractRolloutNameFromTaskRunName(taskRunName);
+ }, [taskRunName]);
+
+ useEffect(() => {
+ const version = ++metadataFetchVersion.current;
+ if (!rolloutName || !taskRunName) {
+ setMetadataFetchState({ status: "idle" });
+ return;
+ }
+
+ setMetadataFetchState({ status: "loading" });
+ void rolloutStore
+ .fetchRolloutByName(rolloutName, true)
+ .then((fetchedRollout) => {
+ if (version !== metadataFetchVersion.current) return;
+ const resolvedTask = getTaskFromRollout(taskRunName, fetchedRollout);
+ if (!resolvedTask) {
+ setMetadataFetchState({
+ status: "error",
+ error: TASK_RESOLUTION_ERROR,
+ });
+ return;
+ }
+ setMetadataFetchState({ status: "success" });
+ })
+ .catch((error: unknown) => {
+ if (version !== metadataFetchVersion.current) return;
+ setMetadataFetchState({
+ status: "error",
+ error: getErrorMessage(error),
+ });
+ });
+ }, [rolloutName, rolloutStore, taskRunName]);
+
+ const rollout = useVueState(() => {
+ if (!rolloutName) return undefined;
+ return rolloutStore.getRolloutByName(rolloutName);
+ });
+
+ const task = useMemo(
+ () => getTaskFromRollout(taskRunName, rollout),
+ [rollout, taskRunName]
+ );
+ const sheetFetchTaskKey = useMemo(() => {
+ if (!task) return "";
+ if (isReleaseBasedTask(task)) {
+ return `release:${task.name}:${releaseNameOfTaskV1(task) ?? ""}`;
+ }
+ return `sheet:${task.name}:${sheetNameOfTaskV1(task) ?? ""}`;
+ }, [task]);
+ const unresolvedTaskMetadataStateKey = useMemo(
+ () => getUnresolvedTaskMetadataStateKey(Boolean(task), metadataFetchState),
+ [metadataFetchState, task]
+ );
+
+ useEffect(() => {
+ const version = ++logFetchVersion.current;
+ setEntries([]);
+
+ if (!taskRunName) {
+ setLogFetchState({ status: "idle" });
+ return;
+ }
+
+ setLogFetchState({ status: "loading" });
+ const request = create(GetTaskRunLogRequestSchema, {
+ parent: taskRunName,
+ });
+ void rolloutServiceClientConnect
+ .getTaskRunLog(request)
+ .then((response) => {
+ if (version !== logFetchVersion.current) return;
+ setEntries(response.entries);
+ setLogFetchState({ status: "success" });
+ })
+ .catch((error: unknown) => {
+ if (version !== logFetchVersion.current) return;
+ setEntries([]);
+ setLogFetchState({
+ status: "error",
+ error: getErrorMessage(error),
+ });
+ });
+ }, [taskRunName]);
+
+ useEffect(() => {
+ const version = ++sheetFetchVersion.current;
+
+ // Always clear both sources when task changes, so previous-task data
+ // cannot be displayed while the new task's requests are in flight.
+ setSheet(undefined);
+ setSheetsMap(new Map());
+
+ if (!task) {
+ setSheetFetchState(
+ buildSheetFetchStateForMissingTask(taskRunName, metadataFetchState)
+ );
+ return;
+ }
+
+ if (isReleaseBasedTask(task)) {
+ setSheetFetchState({ status: "loading", source: "release" });
+ const releaseName = releaseNameOfTaskV1(task);
+ if (!releaseName) {
+ setSheetFetchState({ status: "success", source: "release" });
+ return;
+ }
+
+ void releaseStore
+ .fetchReleaseByName(releaseName, true)
+ .then(async (release) => {
+ const fileSheets = await Promise.all(
+ release.files
+ .filter((file) => file.sheet && file.version)
+ .map(async (file) => {
+ try {
+ const fetchedSheet = await sheetServiceClientConnect.getSheet(
+ {
+ name: file.sheet,
+ raw: true,
+ }
+ );
+ return { version: file.version, sheet: fetchedSheet };
+ } catch (error: unknown) {
+ return {
+ version: file.version,
+ error: getErrorMessage(error),
+ };
+ }
+ })
+ );
+ if (version !== sheetFetchVersion.current) return;
+
+ const releaseResult = buildReleaseSheetFetchResult(
+ fileSheets
+ .filter((item) => item?.version)
+ .map((item) => ({
+ version: item.version,
+ sheet: item.sheet,
+ }))
+ );
+ setSheetsMap(releaseResult.sheetsMap);
+ setSheetFetchState(releaseResult.state);
+ })
+ .catch((error: unknown) => {
+ if (version !== sheetFetchVersion.current) return;
+ setSheetsMap(new Map());
+ setSheetFetchState({
+ status: "error",
+ source: "release",
+ error: getErrorMessage(error),
+ });
+ });
+
+ return;
+ }
+
+ setSheetFetchState({ status: "loading", source: "sheet" });
+ const sheetName = sheetNameOfTaskV1(task);
+ if (!sheetName) {
+ setSheetFetchState({ status: "success", source: "sheet" });
+ return;
+ }
+
+ void sheetServiceClientConnect
+ .getSheet({
+ name: sheetName,
+ raw: true,
+ })
+ .then((fetchedSheet) => {
+ if (version !== sheetFetchVersion.current) return;
+ setSheet(fetchedSheet);
+ setSheetFetchState({ status: "success", source: "sheet" });
+ })
+ .catch((error: unknown) => {
+ if (version !== sheetFetchVersion.current) return;
+ setSheet(undefined);
+ setSheetFetchState({
+ status: "error",
+ source: "sheet",
+ error: getErrorMessage(error),
+ });
+ });
+ }, [
+ releaseStore,
+ task,
+ taskRunName,
+ sheetFetchTaskKey,
+ unresolvedTaskMetadataStateKey,
+ ]);
+
+ return {
+ entries,
+ sheet,
+ sheetsMap,
+ metadataFetch: metadataFetchState,
+ logFetch: logFetchState,
+ sheetFetch: sheetFetchState,
+ };
+};
diff --git a/frontend/src/react/components/task-run-log/useTaskRunLogSections.ts b/frontend/src/react/components/task-run-log/useTaskRunLogSections.ts
new file mode 100644
index 0000000000..13ed89c3ac
--- /dev/null
+++ b/frontend/src/react/components/task-run-log/useTaskRunLogSections.ts
@@ -0,0 +1,513 @@
+import { useEffect, useMemo, useState } from "react";
+import type {
+ TaskRunLogEntry,
+ TaskRunLogEntry_Type,
+} from "@/types/proto-es/v1/rollout_service_pb";
+import type { Sheet } from "@/types/proto-es/v1/sheet_service_pb";
+import type { TaskRunLogDetailText } from "./model";
+import {
+ buildReleaseFileGroups,
+ buildSectionsFromEntries,
+ formatDuration,
+ getEntryTimeRange,
+ getUniqueReplicaIds,
+ groupEntriesByReleaseFile,
+ groupEntriesByReplica,
+ hasReleaseFileMarkers,
+} from "./model";
+import type { ReleaseFileGroup, ReplicaGroup, Section } from "./types";
+
+const addToSet = (set: Set<string>, value: string): Set<string> => {
+ if (set.has(value)) return set;
+ const next = new Set(set);
+ next.add(value);
+ return next;
+};
+
+const deleteFromSet = (set: Set<string>, value: string): Set<string> => {
+ if (!set.has(value)) return set;
+ const next = new Set(set);
+ next.delete(value);
+ return next;
+};
+
+const countSections = (sections: Section[]): number => sections.length;
+const countEntries = (sections: Section[]): number =>
+ sections.reduce((sum, section) => sum + section.entryCount, 0);
+
+export interface UseTaskRunLogSectionsOptions {
+ entries: TaskRunLogEntry[];
+ sheet?: Sheet;
+ sheetsMap?: Map<string, Sheet>;
+ getSectionLabel: (type: TaskRunLogEntry_Type) => string;
+ detailText?: TaskRunLogDetailText;
+ datasetKey?: string;
+}
+
+export interface UseTaskRunLogSectionsResult {
+ sections: Section[];
+ hasMultipleReplicas: boolean;
+ hasReleaseFiles: boolean;
+ releaseFileGroups: ReleaseFileGroup[];
+ replicaGroups: ReplicaGroup[];
+ expandedSections: Set<string>;
+ expandedReplicas: Set<string>;
+ expandedReleaseFiles: Set<string>;
+ toggleSection: (sectionId: string) => void;
+ toggleReplica: (replicaId: string) => void;
+ toggleReleaseFile: (releaseFileId: string) => void;
+ isSectionExpanded: (sectionId: string) => boolean;
+ isReplicaExpanded: (replicaId: string) => boolean;
+ isReleaseFileExpanded: (releaseFileId: string) => boolean;
+ expandAll: () => void;
+ collapseAll: () => void;
+ areAllExpanded: boolean;
+ totalSections: number;
+ totalEntries: number;
+ totalDuration: string;
+}
+
+export const useTaskRunLogSections = ({
+ entries,
+ sheet,
+ sheetsMap,
+ getSectionLabel,
+ detailText,
+ datasetKey,
+}: UseTaskRunLogSectionsOptions): UseTaskRunLogSectionsResult => {
+ const [expandedSections, setExpandedSections] = useState<Set<string>>(
+ () => new Set()
+ );
+ const [userCollapsedSections, setUserCollapsedSections] = useState<
+ Set<string>
+ >(() => new Set());
+ const [expandedReplicas, setExpandedReplicas] = useState<Set<string>>(
+ () => new Set()
+ );
+ const [userCollapsedReplicas, setUserCollapsedReplicas] = useState<
+ Set<string>
+ >(() => new Set());
+ const [expandedReleaseFiles, setExpandedReleaseFiles] = useState<Set<string>>(
+ () => new Set()
+ );
+ const [userCollapsedReleaseFiles, setUserCollapsedReleaseFiles] = useState<
+ Set<string>
+ >(() => new Set());
+
+ const sections = useMemo(() => {
+ return buildSectionsFromEntries(entries, {
+ getSectionLabel,
+ sheet,
+ sheetsMap,
+ detailText,
+ });
+ }, [detailText, entries, getSectionLabel, sheet, sheetsMap]);
+
+ const releaseFileGroups = useMemo(() => {
+ if (!hasReleaseFileMarkers(entries)) return [];
+ return buildReleaseFileGroups(entries, {
+ getSectionLabel,
+ sheet,
+ sheetsMap,
+ detailText,
+ includeOrphanGroup: true,
+ });
+ }, [detailText, entries, getSectionLabel, sheet, sheetsMap]);
+
+ const replicaGroups = useMemo(() => {
+ const replicaIds = getUniqueReplicaIds(entries);
+ if (replicaIds.length <= 1) return [];
+
+ const entriesByReplica = groupEntriesByReplica(entries);
+ return replicaIds.map((replicaId, index) => {
+ const replicaEntries = entriesByReplica.get(replicaId) ?? [];
+ const forceError = index < replicaIds.length - 1;
+
+ if (!hasReleaseFileMarkers(replicaEntries)) {
+ return {
+ replicaId,
+ releaseFileGroups: [],
+ sections: buildSectionsFromEntries(replicaEntries, {
+ getSectionLabel,
+ sheet,
+ sheetsMap,
+ idPrefix: replicaId,
+ forceError,
+ detailText,
+ }),
+ };
+ }
+
+ const releaseEntryGroups = groupEntriesByReleaseFile(replicaEntries);
+ const orphanGroup = releaseEntryGroups.find(
+ (group) => group.file === null
+ );
+ return {
+ replicaId,
+ releaseFileGroups: buildReleaseFileGroups(replicaEntries, {
+ getSectionLabel,
+ sheet,
+ sheetsMap,
+ idPrefix: replicaId,
+ forceError,
+ detailText,
+ }),
+ sections:
+ orphanGroup && orphanGroup.entries.length > 0
+ ? buildSectionsFromEntries(orphanGroup.entries, {
+ getSectionLabel,
+ sheet,
+ sheetsMap,
+ idPrefix: `${replicaId}-orphan`,
+ forceError,
+ detailText,
+ })
+ : [],
+ };
+ });
+ }, [detailText, entries, getSectionLabel, sheet, sheetsMap]);
+
+ const hasReleaseFiles = useMemo(
+ () => hasReleaseFileMarkers(entries),
+ [entries]
+ );
+ const hasMultipleReplicas = replicaGroups.length > 1;
+
+ const allSectionIds = useMemo(() => {
+ if (hasMultipleReplicas) {
+ return replicaGroups.flatMap((group) => [
+ ...group.sections.map((section) => section.id),
+ ...group.releaseFileGroups.flatMap((fileGroup) =>
+ fileGroup.sections.map((section) => section.id)
+ ),
+ ]);
+ }
+ if (hasReleaseFiles) {
+ return releaseFileGroups.flatMap((fileGroup) =>
+ fileGroup.sections.map((section) => section.id)
+ );
+ }
+ return sections.map((section) => section.id);
+ }, [
+ hasMultipleReplicas,
+ hasReleaseFiles,
+ releaseFileGroups,
+ replicaGroups,
+ sections,
+ ]);
+
+ const allReplicaIds = useMemo(() => {
+ return replicaGroups.map((group) => group.replicaId);
+ }, [replicaGroups]);
+
+ const allReleaseFileIds = useMemo(() => {
+ if (hasMultipleReplicas) {
+ return replicaGroups.flatMap((group) =>
+ group.releaseFileGroups.map((fileGroup) => fileGroup.id)
+ );
+ }
+ return releaseFileGroups.map((fileGroup) => fileGroup.id);
+ }, [hasMultipleReplicas, releaseFileGroups, replicaGroups]);
+
+ const resolvedDatasetKey = useMemo(() => {
+ if (datasetKey) return datasetKey;
+ return entries
+ .map((entry) => {
+ return [
+ entry.type,
+ entry.replicaId,
+ entry.logTime?.seconds.toString() ?? "",
+ entry.logTime?.nanos ?? 0,
+ entry.releaseFileExecute?.version ?? "",
+ entry.releaseFileExecute?.filePath ?? "",
+ ].join(":");
+ })
+ .join("|");
+ }, [datasetKey, entries]);
+
+ useEffect(() => {
+ setExpandedSections(new Set());
+ setUserCollapsedSections(new Set());
+ setExpandedReplicas(new Set());
+ setUserCollapsedReplicas(new Set());
+ setExpandedReleaseFiles(new Set());
+ setUserCollapsedReleaseFiles(new Set());
+ }, [resolvedDatasetKey]);
+
+ useEffect(() => {
+ setExpandedSections((previous) => {
+ let next = previous;
+ for (const section of sections) {
+ if (
+ section.status === "error" &&
+ !userCollapsedSections.has(section.id)
+ ) {
+ next = addToSet(next, section.id);
+ }
+ }
+ return next;
+ });
+ }, [sections, userCollapsedSections]);
+
+ useEffect(() => {
+ setExpandedReplicas((previousReplicas) => {
+ let next = previousReplicas;
+ for (const group of replicaGroups) {
+ if (!userCollapsedReplicas.has(group.replicaId)) {
+ next = addToSet(next, group.replicaId);
+ }
+ }
+ return next;
+ });
+
+ setExpandedReleaseFiles((previousFiles) => {
+ let next = previousFiles;
+ for (const group of replicaGroups) {
+ group.releaseFileGroups.forEach((fileGroup) => {
+ const fileId = fileGroup.id;
+ if (!userCollapsedReleaseFiles.has(fileId)) {
+ next = addToSet(next, fileId);
+ }
+ });
+ }
+ return next;
+ });
+
+ setExpandedSections((previousSections) => {
+ let next = previousSections;
+ for (const group of replicaGroups) {
+ for (const section of group.sections) {
+ if (
+ section.status === "error" &&
+ !userCollapsedSections.has(section.id)
+ ) {
+ next = addToSet(next, section.id);
+ }
+ }
+ for (const fileGroup of group.releaseFileGroups) {
+ for (const section of fileGroup.sections) {
+ if (
+ section.status === "error" &&
+ !userCollapsedSections.has(section.id)
+ ) {
+ next = addToSet(next, section.id);
+ }
+ }
+ }
+ }
+ return next;
+ });
+ }, [
+ replicaGroups,
+ userCollapsedReplicas,
+ userCollapsedReleaseFiles,
+ userCollapsedSections,
+ ]);
+
+ useEffect(() => {
+ setExpandedReleaseFiles((previousFiles) => {
+ let next = previousFiles;
+ releaseFileGroups.forEach((fileGroup) => {
+ const fileId = fileGroup.id;
+ if (!userCollapsedReleaseFiles.has(fileId)) {
+ next = addToSet(next, fileId);
+ }
+ });
+ return next;
+ });
+
+ setExpandedSections((previousSections) => {
+ let next = previousSections;
+ for (const fileGroup of releaseFileGroups) {
+ for (const section of fileGroup.sections) {
+ if (
+ section.status === "error" &&
+ !userCollapsedSections.has(section.id)
+ ) {
+ next = addToSet(next, section.id);
+ }
+ }
+ }
+ return next;
+ });
+ }, [releaseFileGroups, userCollapsedReleaseFiles, userCollapsedSections]);
+
+ const toggleSection = (sectionId: string) => {
+ setExpandedSections((previousExpanded) => {
+ const isExpanded = previousExpanded.has(sectionId);
+ setUserCollapsedSections((previousCollapsed) =>
+ isExpanded
+ ? addToSet(previousCollapsed, sectionId)
+ : deleteFromSet(previousCollapsed, sectionId)
+ );
+ return isExpanded
+ ? deleteFromSet(previousExpanded, sectionId)
+ : addToSet(previousExpanded, sectionId);
+ });
+ };
+
+ const toggleReplica = (replicaId: string) => {
+ setExpandedReplicas((previousExpanded) => {
+ const isExpanded = previousExpanded.has(replicaId);
+ setUserCollapsedReplicas((previousCollapsed) =>
+ isExpanded
+ ? addToSet(previousCollapsed, replicaId)
+ : deleteFromSet(previousCollapsed, replicaId)
+ );
+ return isExpanded
+ ? deleteFromSet(previousExpanded, replicaId)
+ : addToSet(previousExpanded, replicaId);
+ });
+ };
+
+ const toggleReleaseFile = (releaseFileId: string) => {
+ setExpandedReleaseFiles((previousExpanded) => {
+ const isExpanded = previousExpanded.has(releaseFileId);
+ setUserCollapsedReleaseFiles((previousCollapsed) =>
+ isExpanded
+ ? addToSet(previousCollapsed, releaseFileId)
+ : deleteFromSet(previousCollapsed, releaseFileId)
+ );
+ return isExpanded
+ ? deleteFromSet(previousExpanded, releaseFileId)
+ : addToSet(previousExpanded, releaseFileId);
+ });
+ };
+
+ const isSectionExpanded = (sectionId: string): boolean => {
+ return expandedSections.has(sectionId);
+ };
+
+ const isReplicaExpanded = (replicaId: string): boolean => {
+ return expandedReplicas.has(replicaId);
+ };
+
+ const isReleaseFileExpanded = (releaseFileId: string): boolean => {
+ return expandedReleaseFiles.has(releaseFileId);
+ };
+
+ const expandAll = () => {
+ setExpandedSections(new Set(allSectionIds));
+ setExpandedReplicas(new Set(allReplicaIds));
+ setExpandedReleaseFiles(new Set(allReleaseFileIds));
+ setUserCollapsedSections(new Set());
+ setUserCollapsedReplicas(new Set());
+ setUserCollapsedReleaseFiles(new Set());
+ };
+
+ const collapseAll = () => {
+ setExpandedSections(new Set());
+ setExpandedReplicas(new Set());
+ setExpandedReleaseFiles(new Set());
+ setUserCollapsedSections(new Set(allSectionIds));
+ setUserCollapsedReplicas(new Set(allReplicaIds));
+ setUserCollapsedReleaseFiles(new Set(allReleaseFileIds));
+ };
+
+ const areAllExpanded =
+ (allSectionIds.length > 0 ||
+ allReleaseFileIds.length > 0 ||
+ allReplicaIds.length > 0) &&
+ (allSectionIds.length === 0 ||
+ allSectionIds.every((id) => expandedSections.has(id))) &&
+ (allReleaseFileIds.length === 0 ||
+ allReleaseFileIds.every((id) => expandedReleaseFiles.has(id))) &&
+ (!hasMultipleReplicas ||
+ allReplicaIds.length === 0 ||
+ allReplicaIds.every((id) => expandedReplicas.has(id)));
+
+ const totalSections = useMemo(() => {
+ if (hasMultipleReplicas) {
+ return replicaGroups.reduce(
+ (sum, group) =>
+ sum +
+ countSections(group.sections) +
+ group.releaseFileGroups.reduce(
+ (fileSum, fileGroup) => fileSum + countSections(fileGroup.sections),
+ 0
+ ),
+ 0
+ );
+ }
+ if (hasReleaseFiles) {
+ return releaseFileGroups.reduce(
+ (sum, fileGroup) => sum + countSections(fileGroup.sections),
+ 0
+ );
+ }
+ return sections.length;
+ }, [
+ hasMultipleReplicas,
+ hasReleaseFiles,
+ releaseFileGroups,
+ replicaGroups,
+ sections.length,
+ ]);
+
+ const totalEntries = useMemo(() => {
+ if (hasMultipleReplicas) {
+ return replicaGroups.reduce(
+ (sum, group) =>
+ sum +
+ countEntries(group.sections) +
+ group.releaseFileGroups.reduce(
+ (fileSum, fileGroup) => fileSum + countEntries(fileGroup.sections),
+ 0
+ ),
+ 0
+ );
+ }
+ if (hasReleaseFiles) {
+ return releaseFileGroups.reduce(
+ (sum, fileGroup) => sum + countEntries(fileGroup.sections),
+ 0
+ );
+ }
+ return countEntries(sections);
+ }, [
+ hasMultipleReplicas,
+ hasReleaseFiles,
+ releaseFileGroups,
+ replicaGroups,
+ sections,
+ ]);
+
+ const totalDuration = useMemo(() => {
+ if (entries.length === 0) return "";
+ const timeRanges = entries.map(getEntryTimeRange);
+ const startTimes = timeRanges
+ .map((range) => range.start)
+ .filter((time) => time > 0);
+ const endTimes = timeRanges
+ .map((range) => range.end)
+ .filter((time) => time > 0);
+ if (startTimes.length === 0 || endTimes.length === 0) return "";
+
+ const startTime = Math.min(...startTimes);
+ const endTime = Math.max(...endTimes);
+ return formatDuration(endTime - startTime);
+ }, [entries]);
+
+ return {
+ sections,
+ hasMultipleReplicas,
+ hasReleaseFiles,
+ releaseFileGroups,
+ replicaGroups,
+ expandedSections,
+ expandedReplicas,
+ expandedReleaseFiles,
+ toggleSection,
+ toggleReplica,
+ toggleReleaseFile,
+ isSectionExpanded,
+ isReplicaExpanded,
+ isReleaseFileExpanded,
+ expandAll,
+ collapseAll,
+ areAllExpanded,
+ totalSections,
+ totalEntries,
+ totalDuration,
+ };
+};
diff --git a/frontend/src/react/locales/en-US.json b/frontend/src/react/locales/en-US.json
index f2bcddab11..ae912ec814 100644
--- a/frontend/src/react/locales/en-US.json
+++ b/frontend/src/react/locales/en-US.json
@@ -324,6 +324,7 @@
"common.key": "Key",
"common.labels": "Labels",
"common.learn-more": "Learn more",
+ "common.load-more": "Load more",
"common.loading": "Loading",
"common.minutes": "Minutes",
"common.no-data": "No data",
@@ -334,6 +335,8 @@
"common.read-only": "Read-only",
"common.restore": "Restore",
"common.sensitive-placeholder": "Sensitive - write only",
+ "common.show-more": "Show more",
+ "common.unknown": "Unknown",
"common.unlimited": "Unlimited",
"common.updated": "Updated",
"common.updating": "Updating",
@@ -543,6 +546,7 @@
},
"database.engine": "Engine",
"database.filter-database": "Filter database",
+ "database.revision.self": "Revision",
"database.sync-complete-for-instance": "Sync complete for instance '{{0}}'",
"db": {
"character-set": "Character set",
@@ -1041,6 +1045,7 @@
"upload-sql": "Upload SQL",
"waiting-approval": "Waiting for Approval"
},
+ "issue.task-run.logs": "Logs",
"label": {
"add-label": "Add label",
"empty-label-value": "Empty",
@@ -1980,6 +1985,27 @@
"running": "Running"
}
},
+ "task-run.log-detail.backing-up": "Backing up...",
+ "task-run.log-detail.backup-completed": "completed ({{count}} tables)",
+ "task-run.log-detail.completed": "Completed",
+ "task-run.log-detail.computing": "Computing...",
+ "task-run.log-detail.dumping": "Dumping...",
+ "task-run.log-detail.retry-attempt": "attempt {{current}}/{{max}}",
+ "task-run.log-detail.syncing": "Syncing...",
+ "task-run.log-type.command-execute": "Command Execute",
+ "task-run.log-type.compute-diff": "Compute Diff",
+ "task-run.log-type.database-sync": "Database Sync",
+ "task-run.log-type.prior-backup": "Prior Backup",
+ "task-run.log-type.release-file-execute": "Release File",
+ "task-run.log-type.retry": "Retry",
+ "task-run.log-type.schema-dump": "Schema Dump",
+ "task-run.log-type.transaction": "Transaction",
+ "task-run.log-viewer.collapse-all": "Collapse all",
+ "task-run.log-viewer.expand-all": "Expand all",
+ "task-run.log-viewer.multiple-replicas-notice": "Server restart detected during execution. Logs are grouped by replica.",
+ "task-run.log-viewer.replica-n": "Replica #{n}",
+ "task-run.log-viewer.summary": "{sections} sections · {entries} entries",
+ "task.affected-rows": "Affected rows",
"two-factor": {
"description": "Two-factor authentication provides an extra layer of security for member accounts. When signing in, you will be required to enter the security code generated by your Authenticator App.",
"disable": {
diff --git a/frontend/src/react/locales/es-ES.json b/frontend/src/react/locales/es-ES.json
index 8fbf88da24..2a585c2230 100644
--- a/frontend/src/react/locales/es-ES.json
+++ b/frontend/src/react/locales/es-ES.json
@@ -324,6 +324,7 @@
"common.key": "Clave",
"common.labels": "Etiquetas",
"common.learn-more": "Aprender más",
+ "common.load-more": "Cargar más",
"common.loading": "Cargando",
"common.minutes": "Minutos",
"common.no-data": "Sin datos",
@@ -334,6 +335,8 @@
"common.read-only": "Solo lectura",
"common.restore": "Restaurar",
"common.sensitive-placeholder": "Sensible - solo escritura",
+ "common.show-more": "Mostrar más",
+ "common.unknown": "Desconocido",
"common.unlimited": "Ilimitado",
"common.updated": "Actualizado",
"common.updating": "Actualizando",
@@ -543,6 +546,7 @@
},
"database.engine": "Motor",
"database.filter-database": "Filtrar base de datos",
+ "database.revision.self": "Revisión",
"database.sync-complete-for-instance": "Sincronización completada para la instancia '{{0}}'",
"db": {
"character-set": "Juego de caracteres",
@@ -1041,6 +1045,7 @@
"upload-sql": "Upload SQL",
"waiting-approval": "A la espera de la aprobación"
},
+ "issue.task-run.logs": "Registros",
"label": {
"add-label": "Agregar etiqueta",
"empty-label-value": "Valor",
@@ -1980,6 +1985,27 @@
"running": "Ejecutándose"
}
},
+ "task-run.log-detail.backing-up": "haciendo copia de seguridad...",
+ "task-run.log-detail.backup-completed": "completadas ({{count}} tablas)",
+ "task-run.log-detail.completed": "Completado",
+ "task-run.log-detail.computing": "computación...",
+ "task-run.log-detail.dumping": "dumping...",
+ "task-run.log-detail.retry-attempt": "intento {{current}}/{{max}}",
+ "task-run.log-detail.syncing": "sincronizando...",
+ "task-run.log-type.command-execute": "Comando Ejecutar",
+ "task-run.log-type.compute-diff": "Calcular diferencia",
+ "task-run.log-type.database-sync": "Sincronización de bases de datos",
+ "task-run.log-type.prior-backup": "Copia de seguridad previa",
+ "task-run.log-type.release-file-execute": "Archivo de lanzamiento",
+ "task-run.log-type.retry": "Reintentar",
+ "task-run.log-type.schema-dump": "Volcado de esquema",
+ "task-run.log-type.transaction": "Transacción",
+ "task-run.log-viewer.collapse-all": "Contraer todo",
+ "task-run.log-viewer.expand-all": "Expandir todo",
+ "task-run.log-viewer.multiple-replicas-notice": "Se detectó un reinicio del servidor durante la ejecución. Los registros están agrupados por réplica.",
+ "task-run.log-viewer.replica-n": "Réplica #{n}",
+ "task-run.log-viewer.summary": "{sections} secciones · {entries} entradas",
+ "task.affected-rows": "Filas afectadas",
"two-factor": {
"description": "La autenticación de dos factores proporciona una capa adicional de seguridad para las cuentas de los miembros. Al iniciar sesión, se te pedirá que ingreses el código de seguridad generado por tu aplicación de autenticación.",
"disable": {
diff --git a/frontend/src/react/locales/ja-JP.json b/frontend/src/react/locales/ja-JP.json
index eb64f5a6be..ac30943432 100644
--- a/frontend/src/react/locales/ja-JP.json
+++ b/frontend/src/react/locales/ja-JP.json
@@ -324,6 +324,7 @@
"common.key": "キー",
"common.labels": "ラベル",
"common.learn-more": "もっと詳しく知る",
+ "common.load-more": "さらに読み込む",
"common.loading": "読み込み中",
"common.minutes": "分",
"common.no-data": "データなし",
@@ -334,6 +335,8 @@
"common.read-only": "読み取り専用",
"common.restore": "復元する",
"common.sensitive-placeholder": "機密データ - 書き込みのみ",
+ "common.show-more": "もっと見る",
+ "common.unknown": "不明",
"common.unlimited": "無制限",
"common.updated": "更新しました",
"common.updating": "更新中",
@@ -543,6 +546,7 @@
},
"database.engine": "エンジン",
"database.filter-database": "フィルターデータベース",
+ "database.revision.self": "リビジョン",
"database.sync-complete-for-instance": "インスタンス '{{0}}' の同期が完了しました",
"db": {
"character-set": "文字セット",
@@ -1041,6 +1045,7 @@
"upload-sql": "Upload SQL",
"waiting-approval": "承認待ち"
},
+ "issue.task-run.logs": "ログ",
"label": {
"add-label": "タグ付けする",
"empty-label-value": "ヌル",
@@ -1980,6 +1985,27 @@
"running": "ランニング"
}
},
+ "task-run.log-detail.backing-up": "バックアップ中...",
+ "task-run.log-detail.backup-completed": "完了しました({{count}} テーブル)",
+ "task-run.log-detail.completed": "完了しました",
+ "task-run.log-detail.computing": "コンピューティング...",
+ "task-run.log-detail.dumping": "ダンピング...",
+ "task-run.log-detail.retry-attempt": "試行 {{current}}/{{max}}",
+ "task-run.log-detail.syncing": "同期中...",
+ "task-run.log-type.command-execute": "コマンド実行",
+ "task-run.log-type.compute-diff": "差分計算",
+ "task-run.log-type.database-sync": "データベース同期",
+ "task-run.log-type.prior-backup": "事前のバックアップ",
+ "task-run.log-type.release-file-execute": "リリースファイル",
+ "task-run.log-type.retry": "リトライ",
+ "task-run.log-type.schema-dump": "スキーマダンプ",
+ "task-run.log-type.transaction": "取引",
+ "task-run.log-viewer.collapse-all": "すべて折りたたむ",
+ "task-run.log-viewer.expand-all": "すべて展開",
+ "task-run.log-viewer.multiple-replicas-notice": "実行中にサーバーの再起動が検出されました。ログはレプリカごとにグループ化されています。",
+ "task-run.log-viewer.replica-n": "レプリカ #{n}",
+ "task-run.log-viewer.summary": "{sections} セクション · {entries} エントリ",
+ "task.affected-rows": "影響を受けた行数",
"two-factor": {
"description": "2 要素認証は、システム メンバーに追加のセキュリティ層を提供します。ログインするとき、ユーザーは認証アプリケーションによって生成されたセキュリティ コードを入力する必要があります。",
"disable": {
diff --git a/frontend/src/react/locales/vi-VN.json b/frontend/src/react/locales/vi-VN.json
index 24cb0e9fc1..4135f6bc2f 100644
--- a/frontend/src/react/locales/vi-VN.json
+++ b/frontend/src/react/locales/vi-VN.json
@@ -324,6 +324,7 @@
"common.key": "Khóa",
"common.labels": "Nhãn",
"common.learn-more": "Tìm hiểu thêm",
+ "common.load-more": "Tải thêm",
"common.loading": "Đang tải",
"common.minutes": "Phút",
"common.no-data": "Không có dữ liệu",
@@ -334,6 +335,8 @@
"common.read-only": "Chỉ đọc",
"common.restore": "Khôi phục",
"common.sensitive-placeholder": "Nhạy cảm - Chỉ ghi",
+ "common.show-more": "Hiển thị thêm",
+ "common.unknown": "Không xác định",
"common.unlimited": "Không giới hạn",
"common.updated": "Đã cập nhật",
"common.updating": "Đang cập nhật",
@@ -543,6 +546,7 @@
},
"database.engine": "Engine",
"database.filter-database": "Lọc cơ sở dữ liệu",
+ "database.revision.self": "Phiên bản",
"database.sync-complete-for-instance": "Đồng bộ hoàn tất cho instance '{{0}}'",
"db": {
"character-set": "Bộ ký tự",
@@ -1041,6 +1045,7 @@
"upload-sql": "Upload SQL",
"waiting-approval": "Đang chờ phê duyệt"
},
+ "issue.task-run.logs": "Nhật ký",
"label": {
"add-label": "Thêm nhãn",
"empty-label-value": "Trống",
@@ -1980,6 +1985,27 @@
"running": "Đang chạy"
}
},
+ "task-run.log-detail.backing-up": "đang sao lưu...",
+ "task-run.log-detail.backup-completed": "đã hoàn thành ({{count}} bảng)",
+ "task-run.log-detail.completed": "Đã hoàn thành",
+ "task-run.log-detail.computing": "tính toán...",
+ "task-run.log-detail.dumping": "đang xuất...",
+ "task-run.log-detail.retry-attempt": "nỗ lực {{current}}/{{max}}",
+ "task-run.log-detail.syncing": "đang đồng bộ hóa...",
+ "task-run.log-type.command-execute": "Lệnh thực thi",
+ "task-run.log-type.compute-diff": "Tính toán chênh lệch",
+ "task-run.log-type.database-sync": "Đồng bộ cơ sở dữ liệu",
+ "task-run.log-type.prior-backup": "Sao lưu trước",
+ "task-run.log-type.release-file-execute": "Tệp phát hành",
+ "task-run.log-type.retry": "Thử lại",
+ "task-run.log-type.schema-dump": "Xuất schema",
+ "task-run.log-type.transaction": "Giao dịch",
+ "task-run.log-viewer.collapse-all": "Thu gọn tất cả",
+ "task-run.log-viewer.expand-all": "Mở rộng tất cả",
+ "task-run.log-viewer.multiple-replicas-notice": "Phát hiện khởi động lại máy chủ trong quá trình thực thi. Nhật ký được nhóm theo bản sao.",
+ "task-run.log-viewer.replica-n": "Bản sao #{n}",
+ "task-run.log-viewer.summary": "{sections} phần · {entries} mục",
+ "task.affected-rows": "Hàng bị ảnh hưởng",
"two-factor": {
"description": "Xác thực hai yếu tố cung cấp một lớp bảo mật bổ sung cho các tài khoản thành viên. Khi đăng nhập, bạn sẽ được yêu cầu nhập mã bảo mật do Ứng dụng xác thực của bạn tạo.",
"disable": {
diff --git a/frontend/src/react/locales/zh-CN.json b/frontend/src/react/locales/zh-CN.json
index a414bd4dd5..ad411a9ffd 100644
--- a/frontend/src/react/locales/zh-CN.json
+++ b/frontend/src/react/locales/zh-CN.json
@@ -324,6 +324,7 @@
"common.key": "键",
"common.labels": "标签",
"common.learn-more": "了解更多",
+ "common.load-more": "加载更多",
"common.loading": "加载中",
"common.minutes": "分钟",
"common.no-data": "无数据",
@@ -334,6 +335,8 @@
"common.read-only": "只读",
"common.restore": "恢复",
"common.sensitive-placeholder": "敏感数据 - 仅写入",
+ "common.show-more": "显示更多",
+ "common.unknown": "未知",
"common.unlimited": "无限制",
"common.updated": "已更新",
"common.updating": "更新中",
@@ -543,6 +546,7 @@
},
"database.engine": "引擎",
"database.filter-database": "过滤数据库",
+ "database.revision.self": "版本",
"database.sync-complete-for-instance": "实例 '{{0}}' 同步完成",
"db": {
"character-set": "字符集",
@@ -1041,6 +1045,7 @@
"upload-sql": "上传 SQL",
"waiting-approval": "等待审批"
},
+ "issue.task-run.logs": "日志",
"label": {
"add-label": "添加标签",
"empty-label-value": "空",
@@ -1980,6 +1985,27 @@
"running": "运行中"
}
},
+ "task-run.log-detail.backing-up": "备份中...",
+ "task-run.log-detail.backup-completed": "已完成({{count}} 个表)",
+ "task-run.log-detail.completed": "已完成",
+ "task-run.log-detail.computing": "计算中...",
+ "task-run.log-detail.dumping": "导出中...",
+ "task-run.log-detail.retry-attempt": "第 {{current}}/{{max}} 次尝试",
+ "task-run.log-detail.syncing": "同步中...",
+ "task-run.log-type.command-execute": "命令执行",
+ "task-run.log-type.compute-diff": "计算差异",
+ "task-run.log-type.database-sync": "数据库同步",
+ "task-run.log-type.prior-backup": "预备份",
+ "task-run.log-type.release-file-execute": "发布包文件",
+ "task-run.log-type.retry": "重试",
+ "task-run.log-type.schema-dump": "结构导出",
+ "task-run.log-type.transaction": "事务",
+ "task-run.log-viewer.collapse-all": "全部收起",
+ "task-run.log-viewer.expand-all": "全部展开",
+ "task-run.log-viewer.multiple-replicas-notice": "检测到执行期间服务重启,日志按副本分组显示。",
+ "task-run.log-viewer.replica-n": "副本 #{n}",
+ "task-run.log-viewer.summary": "{sections} 个分组 · {entries} 条记录",
+ "task.affected-rows": "影响行数",
"two-factor": {
"description": "双重认证为系统成员提供了一个额外的安全层。在登录时,用户需要输入由认证器应用程序生成的安全代码。",
"disable": {
diff --git a/frontend/src/react/pages/project/DatabaseRevisionDetailPage.tsx b/frontend/src/react/pages/project/DatabaseRevisionDetailPage.tsx
new file mode 100644
index 0000000000..42089c155a
--- /dev/null
+++ b/frontend/src/react/pages/project/DatabaseRevisionDetailPage.tsx
@@ -0,0 +1,132 @@
+import { LoaderCircle } from "lucide-react";
+import { useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { RevisionDetailPanel } from "@/react/components/revision";
+import { router } from "@/router";
+import {
+ PROJECT_V1_ROUTE_DATABASE_DETAIL,
+ PROJECT_V1_ROUTE_DATABASES,
+} from "@/router/dashboard/projectV1";
+import { useDatabaseV1Store } from "@/store";
+import { extractDatabaseResourceName } from "@/utils/v1/database";
+import { extractInstanceResourceName } from "@/utils/v1/instance";
+import { extractProjectResourceName } from "@/utils/v1/project";
+
+export function DatabaseRevisionDetailPage({
+ project,
+ instance,
+ database,
+ revisionId,
+}: {
+ project: string;
+ instance: string;
+ database: string;
+ revisionId: string;
+}) {
+ const { t } = useTranslation();
+ const databaseStore = useDatabaseV1Store();
+ const [loading, setLoading] = useState(true);
+ const projectId = extractProjectResourceName(project);
+ const databaseFullName = database;
+ const { databaseName } = extractDatabaseResourceName(database);
+ const instanceId = extractInstanceResourceName(instance);
+ const revisionName = `${databaseFullName}/revisions/${revisionId}`;
+
+ useEffect(() => {
+ let cancelled = false;
+
+ setLoading(true);
+ void databaseStore
+ .getOrFetchDatabaseByName(databaseFullName)
+ .catch((error) => {
+ console.error("Failed to fetch database details", error);
+ })
+ .finally(() => {
+ if (!cancelled) {
+ setLoading(false);
+ }
+ });
+
+ return () => {
+ cancelled = true;
+ };
+ }, [databaseFullName, databaseStore]);
+
+ const handleProjectBreadcrumbClick = () => {
+ router.push({
+ name: PROJECT_V1_ROUTE_DATABASES,
+ params: { projectId },
+ });
+ };
+
+ const handleDatabaseBreadcrumbClick = () => {
+ router.push({
+ name: PROJECT_V1_ROUTE_DATABASE_DETAIL,
+ params: {
+ projectId,
+ instanceId,
+ databaseName,
+ },
+ });
+ };
+
+ const handleRevisionBreadcrumbClick = () => {
+ router.push({
+ name: PROJECT_V1_ROUTE_DATABASE_DETAIL,
+ params: {
+ projectId,
+ instanceId,
+ databaseName,
+ },
+ hash: "#revision",
+ });
+ };
+
+ return (
+ <div className="flex min-h-full flex-col gap-y-4 p-4">
+ <nav aria-label="Breadcrumb" className="mb-4">
+ <ol className="flex flex-wrap items-center gap-x-2 text-sm text-control-light">
+ <li>
+ <button
+ type="button"
+ className="transition-colors hover:text-accent"
+ onClick={handleProjectBreadcrumbClick}
+ >
+ {t("common.databases")}
+ </button>
+ </li>
+ <li aria-hidden="true">/</li>
+ <li>
+ <button
+ type="button"
+ className="transition-colors hover:text-accent"
+ onClick={handleDatabaseBreadcrumbClick}
+ >
+ {databaseName}
+ </button>
+ </li>
+ <li aria-hidden="true">/</li>
+ <li>
+ <button
+ type="button"
+ className="transition-colors hover:text-accent"
+ onClick={handleRevisionBreadcrumbClick}
+ >
+ {t("database.revision.self")}
+ </button>
+ </li>
+ <li aria-hidden="true">/</li>
+ <li className="text-main">{revisionId}</li>
+ </ol>
+ </nav>
+
+ {loading ? (
+ <div className="flex items-center justify-center py-10">
+ <LoaderCircle className="h-4 w-4 animate-spin text-control-light" />
+ </div>
+ ) : (
+ <RevisionDetailPanel revisionName={revisionName} />
+ )}
+ </div>
+ );
+}
diff --git a/frontend/src/router/dashboard/projectV1.ts b/frontend/src/router/dashboard/projectV1.ts
index 00ffe34bc8..1e9ca43ef8 100644
--- a/frontend/src/router/dashboard/projectV1.ts
+++ b/frontend/src/router/dashboard/projectV1.ts
@@ -455,9 +455,9 @@ const projectV1Routes: RouteRecordRaw[] = [
meta: {
requiredPermissionList: () => ["bb.databases.get"],
},
- component: () =>
- import("@/views/DatabaseDetail/RevisionDetail.vue"),
- props: (route) => ({
+ component: () => import("@/react/ReactPageMount.vue"),
+ props: (route: RouteLocationNormalized) => ({
+ page: "DatabaseRevisionDetailPage",
...route.params,
project: `projects/${route.params.projectId}`,
instance: `instances/${route.params.instanceId}`,
diff --git a/frontend/src/views/DatabaseDetail/RevisionDetail.vue b/frontend/src/views/DatabaseDetail/RevisionDetail.vue
deleted file mode 100644
index 12e4c19c34..0000000000
--- a/frontend/src/views/DatabaseDetail/RevisionDetail.vue
+++ /dev/null
@@ -1,46 +0,0 @@
-<template>
- <NBreadcrumb class="mb-4">
- <NBreadcrumbItem @click="router.push(`/${props.project}/databases`)">
- {{ $t("common.databases") }}
- </NBreadcrumbItem>
- <NBreadcrumbItem @click="router.push(databaseV1Url(database))">
- {{ extractDatabaseResourceName(database.name).databaseName }}
- </NBreadcrumbItem>
- <NBreadcrumbItem
- @click="router.push(`${databaseV1Url(database)}#revision`)"
- >
- {{ $t("database.revision.self") }}
- </NBreadcrumbItem>
- <NBreadcrumbItem :clickable="false">
- {{ revisionId }}
- </NBreadcrumbItem>
- </NBreadcrumb>
- <RevisionDetailView
- v-if="ready"
- :database="database"
- :revision-name="`${database.name}/revisions/${revisionId}`"
- />
- <div v-else class="flex justify-center items-center py-10">
- <BBSpin />
- </div>
-</template>
-
-<script lang="ts" setup>
-import { NBreadcrumb, NBreadcrumbItem } from "naive-ui";
-import { useRouter } from "vue-router";
-import { BBSpin } from "@/bbkit";
-import { RevisionDetailPanel as RevisionDetailView } from "@/components/Revision";
-import { useDatabaseV1ByName } from "@/store";
-import { databaseV1Url, extractDatabaseResourceName } from "@/utils";
-
-const props = defineProps<{
- project: string;
- instance: string;
- database: string;
- revisionId: string;
-}>();
-
-const router = useRouter();
-
-const { database, ready } = useDatabaseV1ByName(props.database);
-</script>
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
index 5cd276d579..b6c4be228a 100644
--- a/frontend/tsconfig.app.json
+++ b/frontend/tsconfig.app.json
@@ -7,7 +7,13 @@
"src/**/*.tsx",
"src/**/*.vue"
],
- "exclude": ["src/**/__tests__/*", "src/react/**/*.tsx"],
+ "exclude": [
+ "src/**/__tests__/*",
+ "src/react/**/*.tsx",
+ "src/react/components/task-run-log/index.ts",
+ "src/react/components/monaco/index.ts",
+ "src/react/components/revision/index.ts"
+ ],
"compilerOptions": {
"composite": true,
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
diff --git a/frontend/tsconfig.vitest.json b/frontend/tsconfig.vitest.json
index cca836aa5b..13fd22fe82 100644
--- a/frontend/tsconfig.vitest.json
+++ b/frontend/tsconfig.vitest.json
@@ -7,7 +7,12 @@
"src/**/*.tsx",
"src/**/*.vue"
],
- "exclude": ["src/react/**/*.tsx"],
+ "exclude": [
+ "src/react/**/*.tsx",
+ "src/react/components/task-run-log/index.ts",
+ "src/react/components/monaco/index.ts",
+ "src/react/components/revision/index.ts"
+ ],
"compilerOptions": {
"composite": true,
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.vitest.tsbuildinfo",