diff --git a/app/components/analysis/AnalysesTable.vue b/app/components/analysis/AnalysesTable.vue
index e87ced7..5236be1 100644
--- a/app/components/analysis/AnalysesTable.vue
+++ b/app/components/analysis/AnalysesTable.vue
@@ -7,7 +7,7 @@ import { getAnalysisNodes } from "~/composables/useAPIFetch";
 import { formatDataRow } from "~/utils/format-data-row";
 import {
   showCacheWarningToast,
-  showConnectionErrorToast
+  showConnectionErrorToast,
 } from "~/composables/connectionErrorToast";
 import { FilterMatchMode } from "@primevue/core/api";
 import SearchBar from "~/components/table/SearchBar.vue";
@@ -15,7 +15,7 @@ import AnalysisControlButtons from "./AnalysisControlButtons.vue";
 import {
   getApprovalStatusSeverity,
   getBuildStatusSeverity,
-  getExecutionStatusSeverity
+  getExecutionStatusSeverity,
 } from "~/utils/status-tag-severity";
 import {
   type AnalysisNode,
@@ -24,7 +24,7 @@ import {
   type PodProgressResponse,
   PodStatus,
   type Project,
-  type Route
+  type Route,
 } from "~/services/Api";
 import { ApprovalStatus } from "~/types/node";
 import ContainerCounter from "~/components/analysis/ContainerCounter.vue";
@@ -40,12 +40,12 @@ const { nodeType, requireDataStore: datastoreRequired } =
   useDatastoreRequirement();
 
 const datastoreBadgeSeverity = computed(() =>
-  datastoreRequired.value ? "danger" : "secondary"
+  datastoreRequired.value ? "danger" : "secondary",
 );
 const datastoreBadgeTooltip = computed(() =>
   datastoreRequired.value
     ? "Data store missing!"
-    : "Data store missing, but not required"
+    : "Data store missing, but not required",
 );
 
 const analysesMap = ref<Map<string, ModifiedAnalysisNode>>(new Map());
@@ -61,11 +61,11 @@ const filters = ref();
 // Cache
 const analysisCache = useState<AnalysisNode[] | undefined>(
   "analysisCache",
-  () => undefined
+  () => undefined,
 );
 const projectCache = useState<Project[] | undefined>(
   "projectCache",
-  () => undefined
+  () => undefined,
 );
 const podOrcUnreacheable = ref(false);
 
@@ -81,9 +81,7 @@ const approvalStatuses = Object.values(ApprovalStatus);
 const processStatuses = Object.values(ProcessStatus);
 const podStatuses = Object.values(PodStatus);
 
-// Stable sort function for distribution status column — maps to binary value so
-// rows group by badge (executed = '1', everything else = '0') rather than sorting
-// alphabetically across the many possible status strings.
+// Stable sort function for distribution status column maps to binary value
 const distributionStatusSortFn = (row: ModifiedAnalysisNode) =>
   row.analysis?.distribution_status === "executed" ? "1" : "0";
 
@@ -95,8 +93,8 @@ async function getProjects() {
       method: "GET",
       query: {
         sort: "-updated_at",
-        fields: "id,name"
-      }
+        fields: "id,name",
+      },
     })
     .catch(() => undefined)) as Project[];
 }
@@ -104,7 +102,7 @@ async function getProjects() {
 async function getKongRoutes() {
   const kongRoutesResp = (await useNuxtApp()
     .$hubApi("/kong/project", {
-      method: "GET"
+      method: "GET",
     })
     .catch(() => undefined)) as ListRoutes;
   if (kongRoutesResp && kongRoutesResp.data) {
@@ -141,53 +139,30 @@ async function parseProjects() {
   }
 }
 
-// /**
-//  * Changes to "executing" to "running" and "executed" to "finished" which is simpler language.
-//  * @param status
-//  */
-// function useCommonLanguage(
-//   status: PodStatus,
-// ): PodStatus | "running" | "finished" {
-//   if (status === PodStatus.Executing) {
-//     return PodStatus.Running;
-//   } else if (status === PodStatus.Executed) {
-//     return PodStatus.Finished;
-//   } else {
-//     return status;
-//   }
-// }
-
 async function getExecutionStatusesFromPodOrc(): Promise<
   PodProgressResponse | undefined
 > {
   const podOrcResponse = (await useNuxtApp()
     .$hubApi("/po/status", {
-      method: "GET"
+      method: "GET",
     })
     .catch(() => {
-      showConnectionErrorToast(toast, {
-        severity: "warn",
-        summary: "Missing PO Status Update",
-        detail:
-          "Unable to retrieve pod statuses from the PO, relying on information from the Hub",
-        life: 3000
-      });
+      if (!podOrcUnreacheable.value) {
+        podOrcUnreacheable.value = true;
+        showConnectionErrorToast(toast, {
+          severity: "warn",
+          summary: "Missing PO Status Update",
+          detail:
+            "Unable to retrieve pod statuses from the PO, relying on information from the Hub",
+          life: 3000,
+        });
+      }
+      return undefined;
     })) as PodProgressResponse;
   podOrcUnreacheable.value = !podOrcResponse;
   return podOrcResponse;
 }
 
-async function checkForUpdatesFromPodOrc() {
-  if (!podOrcUnreacheable.value) {
-    const newStatuses = await getExecutionStatusesFromPodOrc();
-    if (newStatuses) {
-      for (const [analysisId, progressData] of Object.entries(newStatuses)) {
-        updateAnalysisRun(analysisId, progressData);
-      }
-    }
-  }
-}
-
 function setProgress(analysis: ModifiedAnalysisNode): ModifiedAnalysisNode {
   // For testing: Math.round(Math.random() * 100);
   analysis.execution_progress = analysis.execution_progress
@@ -198,10 +173,7 @@ function setProgress(analysis: ModifiedAnalysisNode): ModifiedAnalysisNode {
   if (currentRunStatus) {
     if (currentRunStatus === PodStatus.Failed) {
       analysis.execution_progress = 0;
-    } else if (
-      currentRunStatus === PodStatus.Executed ||
-      currentRunStatus === PodStatus.Finished // deprecated
-    ) {
+    } else if (currentRunStatus === PodStatus.Executed) {
       analysis.execution_progress = 100;
     }
   }
@@ -222,13 +194,13 @@ function determineProgressBarColor(progress: number) {
   }
 
   return {
-    "--p-progressbar-value-background": color
+    "--p-progressbar-value-background": color,
   };
 }
 
 function parseAnalysis(
   analysisEntry: ModifiedAnalysisNode,
-  executionStatuses: PodProgressResponse | undefined
+  executionStatuses: PodProgressResponse | undefined,
 ): ModifiedAnalysisNode {
   const projId = analysisEntry.analysis?.project_id;
   const analysisId = analysisEntry.analysis_id;
@@ -236,14 +208,9 @@ function parseAnalysis(
     analysisEntry.project_name = projMap.has(projId) ? projMap.get(projId) : "";
     analysisEntry.datastore = kongRoutes.value.has(projId);
   }
-  // If PodOrc status update returns undefined -> use hub info since it's all we have
-  // If status from PodOrc -> use it
-  // If no run status reported by PodOrc, and it's not failed/finished -> set to null (wrong hub info)
-  // REMEMBER: PO sends running/finished instead of executing/executed
   const acceptableHubStatuses: Array<PodStatus | null | undefined> = [
     PodStatus.Failed,
     PodStatus.Executed,
-    PodStatus.Finished // Deprecated but still returned by PO
   ];
   if (executionStatuses && analysisId in executionStatuses) {
     const podStatus = executionStatuses[analysisId]!;
@@ -260,9 +227,10 @@ function parseAnalysis(
 
 async function compileAnalysisTable(
   respStatus: string,
-  respData: AnalysisNode[] | undefined
+  respData: AnalysisNode[] | undefined,
+  silent = false,
 ) {
-  tableLoading.value = true;
+  if (!silent) tableLoading.value = true;
   await parseProjects();
   await getKongRoutes();
   const parsedAnalyses = new Map<string, ModifiedAnalysisNode>();
@@ -281,13 +249,13 @@ async function compileAnalysisTable(
   const formattedAnalyses = formatDataRow(
     analysisData,
     ["created_at", "updated_at"],
-    expandRowEntries
+    expandRowEntries,
   ) as ModifiedAnalysisNode[];
   if (formattedAnalyses && projMap.size > 0) {
     formattedAnalyses.forEach((analysisEntry: ModifiedAnalysisNode) => {
       parsedAnalyses.set(
         analysisEntry.analysis_id,
-        parseAnalysis(analysisEntry, currentExecutionStatuses)
+        parseAnalysis(analysisEntry, currentExecutionStatuses),
       );
     });
     analysesMap.value = parsedAnalyses;
@@ -295,17 +263,27 @@ async function compileAnalysisTable(
   tableLoading.value = false;
 }
 
-let pollIntervalId: ReturnType<typeof setInterval> | undefined;
+let tableRefreshIntervalId: ReturnType<typeof setInterval> | undefined;
+let isPolling = false;
+
+async function pollTableData() {
+  if (isPolling) return;
+  isPolling = true;
+  try {
+    await refresh();
+    await compileAnalysisTable(status.value, analysisNodeResp.value, true);
+  } finally {
+    isPolling = false;
+  }
+}
 
 onMounted(() => {
   compileAnalysisTable(status.value, analysisNodeResp.value);
-  pollIntervalId = setInterval(checkForUpdatesFromPodOrc, 15000); // Poll PO every 15 seconds
+  tableRefreshIntervalId = setInterval(pollTableData, 15000);
 });
 
 onUnmounted(() => {
-  if (pollIntervalId) {
-    clearInterval(pollIntervalId);
-  }
+  if (tableRefreshIntervalId) clearInterval(tableRefreshIntervalId);
 });
 
 async function onTableRefresh() {
@@ -334,11 +312,11 @@ async function getNextPage() {
       query: {
         page: {
           offset: currentOffset,
-          limit: queryLimit
+          limit: queryLimit,
         },
         include: "analysis,node",
-        sort: "-updated_at"
-      }
+        sort: "-updated_at",
+      },
     })
     .catch(() => undefined)) as AnalysisNode[];
   if (nextSetResults.length > 0) {
@@ -359,7 +337,7 @@ const defaultFilters = {
   global: { value: undefined, matchMode: FilterMatchMode.CONTAINS },
   approval_status: { value: undefined, matchMode: FilterMatchMode.EQUALS },
   "analysis.build_status": { value: undefined, matchMode: FilterMatchMode.IN },
-  execution_status: { value: undefined, matchMode: FilterMatchMode.IN }
+  execution_status: { value: undefined, matchMode: FilterMatchMode.IN },
 };
 filters.value = defaultFilters;
 
@@ -367,7 +345,7 @@ function resetFilters() {
   const clearedFilters = {};
   for (const filterKey in defaultFilters) {
     clearedFilters[filterKey] = {
-      ...defaultFilters[filterKey]
+      ...defaultFilters[filterKey],
     };
     clearedFilters[filterKey].value = undefined;
   }
@@ -380,7 +358,7 @@ const updateFilters = (filterText: string) => {
 
 function updateAnalysisRun(
   analysisId: string,
-  newStatusData: AnalysisStatus | undefined
+  newStatusData: AnalysisStatus | undefined,
 ) {
   if (analysesMap.value.has(analysisId)) {
     const analysisToUpdate = analysesMap.value.get(analysisId)!; // Tell typescript we are sure there is a value
@@ -402,7 +380,7 @@ function updateExecutionStatusFilter(filterText: string) {
     if (currentExecutionStatusFilters.includes(filterText)) {
       // If filter already there, then remove it
       const filteredStatuses = currentExecutionStatusFilters.filter(
-        (item) => item !== filterText
+        (item) => item !== filterText,
       );
       if (filteredStatuses.length == 0) {
         // If empty array after filtering then set to null
@@ -425,7 +403,7 @@ const showDataStoreNavToast = () => {
       "Unable to find an associated data store, click the button below " +
       "to create a data store for the project of this analysis",
     group: "datastoreToastLink",
-    life: 10000
+    life: 10000,
   });
 };
 
@@ -659,15 +637,15 @@ const onCloseNavToast = () => {
                 class="distribution-badge"
               >
                 <Badge class="w-8 h-8 rounded-full" severity="success"
-                ><i v-tooltip.top="'Image available'" class="pi pi-check"></i
+                  ><i v-tooltip.top="'Image available'" class="pi pi-check"></i
                 ></Badge>
               </div>
               <div v-else class="distribution-badge">
                 <Badge class="w-8 h-8 rounded-full" :severity="'danger'"
-                ><i
-                  v-tooltip.top="'Image unavailable'"
-                  class="pi pi-times"
-                ></i
+                  ><i
+                    v-tooltip.top="'Image unavailable'"
+                    class="pi pi-times"
+                  ></i
                 ></Badge>
               </div>
             </template>
@@ -749,17 +727,17 @@ const onCloseNavToast = () => {
             <template #body="{ data }">
               <div v-if="data.datastore" class="datastore-badge">
                 <Badge class="w-8 h-8 rounded-full" severity="success"
-                ><i v-tooltip.top="'Data store found'" class="pi pi-check"></i
+                  ><i v-tooltip.top="'Data store found'" class="pi pi-check"></i
                 ></Badge>
               </div>
               <div v-else class="datastore-badge">
                 <Badge
                   class="w-8 h-8 rounded-full"
                   :severity="datastoreBadgeSeverity"
-                ><i
-                  v-tooltip.top="datastoreBadgeTooltip"
-                  class="pi pi-times"
-                ></i
+                  ><i
+                    v-tooltip.top="datastoreBadgeTooltip"
+                    class="pi pi-times"
+                  ></i
                 ></Badge>
               </div>
             </template>
diff --git a/app/components/analysis/AnalysisControlButtons.vue b/app/components/analysis/AnalysisControlButtons.vue
index bb10eda..5a95992 100644
--- a/app/components/analysis/AnalysisControlButtons.vue
+++ b/app/components/analysis/AnalysisControlButtons.vue
@@ -440,6 +440,7 @@ async function onDeleteAnalysis() {
       :to="{
         name: 'analyses-id',
         params: { id: props.analysisId },
+        query: { nodeId: props.analysisNodeId },
       }"
       target="_blank"
     >
diff --git a/app/components/analysis/logs/AnalysisLogCardContent.vue b/app/components/analysis/logs/AnalysisLogCardContent.vue
index faad238..89f5097 100644
--- a/app/components/analysis/logs/AnalysisLogCardContent.vue
+++ b/app/components/analysis/logs/AnalysisLogCardContent.vue
@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { Card, ScrollPanel } from "primevue";
-import { computed, onMounted, onUpdated, ref } from "vue";
+import { computed, onBeforeUpdate, onMounted, onUpdated, ref } from "vue";
 import { useToast } from "primevue/usetoast";
 import Toast from "primevue/toast";
 import type { PodLog } from "~/services/Api";
@@ -15,18 +15,42 @@ const showTimestamps = ref(false);
 
 const toast = useToast();
 
-const scrollToBottom = (element) => {
-  element.scrollIntoView({ behavior: "smooth", block: "nearest" });
-};
+const getScrollContainer = (bottomEl: HTMLElement): HTMLElement | null =>
+  bottomEl?.parentElement ?? null;
+
+const isAtBottom = (container: HTMLElement): boolean =>
+  container.scrollTop + container.clientHeight >= container.scrollHeight - 10;
+
+let nginxWasAtBottom = true;
+let analysisWasAtBottom = true;
+
+onBeforeUpdate(() => {
+  if (nginxLogBottom.value) {
+    const c = getScrollContainer(nginxLogBottom.value);
+    nginxWasAtBottom = c ? isAtBottom(c) : true;
+  }
+  if (analysisLogBottom.value) {
+    const c = getScrollContainer(analysisLogBottom.value);
+    analysisWasAtBottom = c ? isAtBottom(c) : true;
+  }
+});
 
 onMounted(() => {
-  scrollToBottom(nginxLogBottom.value);
-  scrollToBottom(analysisLogBottom.value);
+  [nginxLogBottom, analysisLogBottom].forEach(({ value }) => {
+    const c = getScrollContainer(value);
+    if (c) c.scrollTop = c.scrollHeight;
+  });
 });
 
 onUpdated(() => {
-  scrollToBottom(nginxLogBottom.value);
-  scrollToBottom(analysisLogBottom.value);
+  if (nginxWasAtBottom && nginxLogBottom.value) {
+    const c = getScrollContainer(nginxLogBottom.value);
+    if (c) c.scrollTop = c.scrollHeight;
+  }
+  if (analysisWasAtBottom && analysisLogBottom.value) {
+    const c = getScrollContainer(analysisLogBottom.value);
+    if (c) c.scrollTop = c.scrollHeight;
+  }
 });
 
 function formatTimestamp(ts: string): string {
diff --git a/app/components/analysis/logs/ContainerLogs.vue b/app/components/analysis/logs/ContainerLogs.vue
index 9a0c523..bc4913c 100644
--- a/app/components/analysis/logs/ContainerLogs.vue
+++ b/app/components/analysis/logs/ContainerLogs.vue
@@ -9,43 +9,72 @@ import { useNuxtApp } from "nuxt/app";
 import type {
   AnalysisLogHistoryResponse,
   AnalysisLogsResponse,
+  AnalysisNode,
   RunLogs,
 } from "~/services/Api";
+import { ProcessStatus } from "~/types/analysis";
 
 const route = useRoute();
 const analysisId = route.params.id as string;
+const analysisNodeId = route.query.nodeId as string | undefined;
 const currentLogs = ref<AnalysisLogsResponse | null>(null);
 const prevLogs = ref<RunLogs[]>([]);
+const analysis = ref<AnalysisNode | null>(null);
 
 const {
   data: response,
-  refresh,
   status,
   error,
-} = await getAnalysisLogs(analysisId);
+} = await getAnalysisLogs(analysisId, { limit: null });
+
+const lastFetchedAt = ref<string | null>(null);
 
 gatherCurrentLogs();
-await gatherPreviousLogs();
+await Promise.all([gatherPreviousLogs(), fetchAnalysis()]);
 
 function gatherCurrentLogs() {
   if (status.value === "success") {
     currentLogs.value = response.value ?? null;
+    if (currentLogs.value) {
+      lastFetchedAt.value = new Date().toISOString();
+    }
   } else if (status.value === "error" && error.value?.statusCode === 403) {
     navigateTo("/error/403");
   }
 }
 
+async function fetchAnalysis() {
+  if (!analysisNodeId) return;
+  const result = (await useNuxtApp()
+    .$hubApi(`/analysis-nodes/${analysisNodeId}`, {
+      method: "GET",
+      query: {
+        include: "analysis",
+      },
+    })
+    .catch(() => undefined)) as AnalysisNode | undefined;
+  if (result) {
+    analysis.value = result;
+  }
+}
+
 async function gatherPreviousLogs() {
   const historyResp = (await useNuxtApp()
     .$hubApi(`/history/${analysisId}`, {
       method: "GET",
+      query: {
+        limit: null,
+      },
     })
     .catch(() => undefined)) as AnalysisLogHistoryResponse | undefined;
 
   if (historyResp?.runs) {
     const currentRunNumber = currentLogs.value?.run_number;
     prevLogs.value = [...historyResp.runs]
-      .filter((r) => currentRunNumber === undefined || r.run_number !== currentRunNumber)
+      .filter(
+        (r) =>
+          currentRunNumber === undefined || r.run_number !== currentRunNumber,
+      )
       .sort((a, b) => b.run_number - a.run_number);
   }
 }
@@ -55,12 +84,43 @@ const { pause, resume, isActive } = useIntervalFn(
     refreshLogs();
   },
   5000,
-  { immediate: currentLogs.value !== null },
+  { immediate: analysis.value?.execution_status === ProcessStatus.Executing },
 );
 
 async function refreshLogs() {
-  await refresh();
-  gatherCurrentLogs();
+  if (!lastFetchedAt.value) {
+    const fetchTime = new Date().toISOString();
+    const result = await useNuxtApp()
+      .$hubApi<AnalysisLogsResponse>(`/logs/${analysisId}`, {
+        method: "GET",
+        query: { limit: null },
+      })
+      .catch(() => undefined);
+    if (result) {
+      currentLogs.value = result;
+      lastFetchedAt.value = fetchTime;
+    }
+    return;
+  }
+
+  const fetchTime = new Date().toISOString();
+  const result = await useNuxtApp()
+    .$hubApi<AnalysisLogsResponse>(`/logs/${analysisId}`, {
+      method: "GET",
+      query: { start_date: lastFetchedAt.value },
+    })
+    .catch(() => undefined);
+  if (result && currentLogs.value) {
+    currentLogs.value = {
+      ...currentLogs.value,
+      analysis_logs: [
+        ...currentLogs.value.analysis_logs,
+        ...result.analysis_logs,
+      ],
+      nginx_logs: [...currentLogs.value.nginx_logs, ...result.nginx_logs],
+    };
+  }
+  lastFetchedAt.value = fetchTime;
 }
 
 const previousRunsList = computed(() =>
@@ -82,8 +142,8 @@ function onRefreshToggle() {
       <div class="table-header-row">
         <span>{{ analysisId }}</span>
         <RefreshSwitch
-          :disabled="!currentLogs"
-          :startEnabled="currentLogs !== null"
+          :disabled="analysis?.execution_status !== ProcessStatus.Executing"
+          :startEnabled="analysis?.execution_status === ProcessStatus.Executing"
           @change="onRefreshToggle"
         />
       </div>
diff --git a/app/components/header/AvatarButton.vue b/app/components/header/AvatarButton.vue
index 5f48a84..c15a1f4 100644
--- a/app/components/header/AvatarButton.vue
+++ b/app/components/header/AvatarButton.vue
@@ -30,7 +30,9 @@ const menuItems = computed(() => [
         icon: isAuthenticated.value ? "pi pi-sign-out" : "pi pi-sign-in",
         command: () => {
           // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-          isAuthenticated.value ? signOut() : signIn(`${idpProvider}`);
+          isAuthenticated.value
+            ? signOut({ callbackUrl: "/" })
+            : signIn(`${idpProvider}`);
         },
       },
       {
diff --git a/app/components/landing/IdpAuthBtns.vue b/app/components/landing/IdpAuthBtns.vue
index f914ee0..5f33d6a 100644
--- a/app/components/landing/IdpAuthBtns.vue
+++ b/app/components/landing/IdpAuthBtns.vue
@@ -25,7 +25,7 @@ const idpNameCapitalized: string =
         class="idp-auth-success"
         outlined
         severity="success"
-        @click="signIn(`${idpProvider}`)"
+        @click="signIn(idpProvider)"
         >Login with {{ idpNameCapitalized }}
       </Button>
     </div>
diff --git a/app/composables/useAPIFetch.ts b/app/composables/useAPIFetch.ts
index c94dd7f..d4a4ba4 100644
--- a/app/composables/useAPIFetch.ts
+++ b/app/composables/useAPIFetch.ts
@@ -156,10 +156,15 @@ export function deleteAnalysisFromKong(analysisId: string, opts?) {
 }
 
 // PodOrc endpoints
-export function getAnalysisLogs(analysisId: string, opts?) {
+export function getAnalysisLogs(
+  analysisId: string,
+  query?: { limit?: number | null; start_date?: string | null },
+  opts?,
+) {
   return useAPIFetch<AnalysisLogsResponse>(`/logs/${analysisId}`, {
     ...opts,
     method: "GET",
+    query,
   });
 }
 
diff --git a/app/services/Api.ts b/app/services/Api.ts
index 6078c66..613b87f 100644
--- a/app/services/Api.ts
+++ b/app/services/Api.ts
@@ -405,6 +405,19 @@ export interface AnalysisStatus {
   progress?: number | null;
 }
 
+/**
+ * ApiRequestCountResponse
+ * Response for the API request count endpoint.
+ *
+ * data maps endpoint path → {method: count, ..., "total": count}.
+ */
+export interface ApiRequestCountResponse {
+  /** Total */
+  total: number;
+  /** Data */
+  data: Record<string, Record<string, number>>;
+}
+
 /**
  * AutostartSettings
  * Autostart Settings.
@@ -1162,6 +1175,40 @@ export interface ListServices {
   offset?: string | null;
 }
 
+/**
+ * LogQLQueryRequest
+ * Request body for a raw LogQL query.
+ */
+export interface LogQLQueryRequest {
+  /** Query */
+  query: string;
+  /**
+   * Limit
+   * @default 50
+   */
+  limit?: number;
+  /**
+   * Offset
+   * @default 0
+   */
+  offset?: number;
+  /** Start */
+  start?: string | null;
+  /** End */
+  end?: string | null;
+}
+
+/**
+ * LogQLQueryResponse
+ * Response for a raw LogQL query.
+ */
+export interface LogQLQueryResponse {
+  /** Data */
+  data: Record<string, any>[];
+  /** Event log metadata model. */
+  meta: Meta;
+}
+
 /** MasterImage */
 export interface MasterImage {
   /**
@@ -1225,7 +1272,7 @@ export interface Meta {
   /** Limit */
   limit: number;
   /** Offset */
-  offset: number;
+  offset?: number | null;
 }
 
 /**
@@ -1259,6 +1306,48 @@ export interface MinioConfig {
   strip_path_pattern?: string | null;
 }
 
+/** NetStatResponse */
+export interface NetStatResponse {
+  /** Data */
+  data: NetStatTotal[];
+  /** Event log metadata model. */
+  meta: Meta;
+}
+
+/** NetStatRun */
+export interface NetStatRun {
+  /**
+   * Timestamp
+   * @format date-time
+   */
+  timestamp: string;
+  /** Container */
+  container: string;
+  /** Run Number */
+  run_number: number;
+  /** Pod */
+  pod: string;
+  /** Bytes In */
+  bytes_in: number;
+  /** Bytes Out */
+  bytes_out: number;
+}
+
+/** NetStatTotal */
+export interface NetStatTotal {
+  /**
+   * Analysis Id
+   * @format uuid
+   */
+  analysis_id: string;
+  /** Bytes In */
+  bytes_in: number;
+  /** Bytes Out */
+  bytes_out: number;
+  /** Runs */
+  runs: NetStatRun[];
+}
+
 /** Node */
 export interface Node {
   /** External Name */
@@ -3428,15 +3517,63 @@ export class Api<
      */
     logsAnalysisLiveGetLogsAnalysisIdGet: (
       analysisId: string,
+      query?: {
+        /**
+         * Start Date
+         * Filter logs from this timestamp using ISO8601 format
+         */
+        start_date?: string | null;
+        /**
+         * End Date
+         * Filter logs up to this timestamp using ISO8601 format
+         */
+        end_date?: string | null;
+        /**
+         * Limit
+         * Maximum number of log lines to return per container
+         * @default 1000
+         */
+        limit?: number | null;
+        /**
+         * Offset
+         * Number of log lines to skip per container
+         * @default 0
+         */
+        offset?: number | null;
+      },
       params: RequestParams = {},
     ) =>
       this.request<AnalysisLogsResponse, void | HTTPValidationError>({
         path: `/logs/${analysisId}`,
         method: "GET",
+        query: query,
         secure: true,
         format: "json",
         ...params,
       }),
+
+    /**
+     * @description Execute a raw LogQL query against VictoriaLogs. Admin only.
+     *
+     * @tags Logs
+     * @name LogsQueryRawLogsQueryPost
+     * @summary Logs.Query.Raw
+     * @request POST:/logs/query
+     * @secure
+     */
+    logsQueryRawLogsQueryPost: (
+      data: LogQLQueryRequest,
+      params: RequestParams = {},
+    ) =>
+      this.request<LogQLQueryResponse, void | HTTPValidationError>({
+        path: `/logs/query`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+      }),
   };
   history = {
     /**
@@ -3450,11 +3587,125 @@ export class Api<
      */
     logsAnalysisHistoryGetHistoryAnalysisIdGet: (
       analysisId: string,
+      query?: {
+        /**
+         * Start Date
+         * Filter logs from this timestamp using ISO8601 format
+         */
+        start_date?: string | null;
+        /**
+         * End Date
+         * Filter logs up to this timestamp using ISO8601 format
+         */
+        end_date?: string | null;
+        /**
+         * Limit
+         * Maximum number of log lines to return per container
+         * @default 1000
+         */
+        limit?: number;
+        /**
+         * Offset
+         * Number of log lines to skip per container
+         * @default 0
+         */
+        offset?: number;
+      },
       params: RequestParams = {},
     ) =>
       this.request<AnalysisLogHistoryResponse, void | HTTPValidationError>({
         path: `/history/${analysisId}`,
         method: "GET",
+        query: query,
+        secure: true,
+        format: "json",
+        ...params,
+      }),
+  };
+  netstats = {
+    /**
+     * @description Retrieve network traffic statistics from netstats log events.
+     *
+     * @tags Logs
+     * @name LogsNetstatsGetNetstatsGet
+     * @summary Logs.Netstats.Get
+     * @request GET:/netstats
+     * @secure
+     */
+    logsNetstatsGetNetstatsGet: (
+      query?: {
+        /**
+         * Analysis Id
+         * Filter by analysis UUID
+         */
+        analysis_id?: string | null;
+        /**
+         * Start Date
+         * Filter by start date using ISO8601 format
+         */
+        start_date?: string | null;
+        /**
+         * End Date
+         * Filter by end date using ISO8601 format
+         */
+        end_date?: string | null;
+        /**
+         * Limit
+         * Maximum number of raw log entries to return
+         * @default 1000
+         */
+        limit?: number;
+      },
+      params: RequestParams = {},
+    ) =>
+      this.request<NetStatResponse, void | HTTPValidationError>({
+        path: `/netstats`,
+        method: "GET",
+        query: query,
+        secure: true,
+        format: "json",
+        ...params,
+      }),
+  };
+  requests = {
+    /**
+     * @description Get total API request count and a per-endpoint breakdown grouped by HTTP method and path.
+     *
+     * @tags Logs
+     * @name LogsRequestsGetRequestsGet
+     * @summary Logs.Requests.Get
+     * @request GET:/requests
+     * @secure
+     */
+    logsRequestsGetRequestsGet: (
+      query?: {
+        /**
+         * Start Date
+         * Filter requests from this timestamp using ISO8601 format
+         */
+        start_date?: string | null;
+        /**
+         * End Date
+         * Filter requests up to this timestamp using ISO8601 format
+         */
+        end_date?: string | null;
+        /**
+         * Endpoint
+         * Filter breakdown to paths starting with this prefix
+         */
+        endpoint?: string | null;
+        /**
+         * Method
+         * Filter breakdown to a specific HTTP method (e.g. GET, POST, DELETE)
+         */
+        method?: string | null;
+      },
+      params: RequestParams = {},
+    ) =>
+      this.request<ApiRequestCountResponse, void | HTTPValidationError>({
+        path: `/requests`,
+        method: "GET",
+        query: query,
         secure: true,
         format: "json",
         ...params,
diff --git a/app/services/hub_adapter_swagger.json b/app/services/hub_adapter_swagger.json
index bd9b02c..270d2fd 100644
--- a/app/services/hub_adapter_swagger.json
+++ b/app/services/hub_adapter_swagger.json
@@ -2839,6 +2839,82 @@
               "title": "Analysis Id"
             },
             "description": "UUID of the analysis."
+          },
+          {
+            "name": "start_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter logs from this timestamp using ISO8601 format",
+              "title": "Start Date"
+            },
+            "description": "Filter logs from this timestamp using ISO8601 format"
+          },
+          {
+            "name": "end_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter logs up to this timestamp using ISO8601 format",
+              "title": "End Date"
+            },
+            "description": "Filter logs up to this timestamp using ISO8601 format"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Maximum number of log lines to return per container",
+              "default": 1000,
+              "title": "Limit"
+            },
+            "description": "Maximum number of log lines to return per container"
+          },
+          {
+            "name": "offset",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Number of log lines to skip per container",
+              "default": 0,
+              "title": "Offset"
+            },
+            "description": "Number of log lines to skip per container"
           }
         ],
         "responses": {
@@ -2891,6 +2967,68 @@
               "title": "Analysis Id"
             },
             "description": "UUID of the analysis."
+          },
+          {
+            "name": "start_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter logs from this timestamp using ISO8601 format",
+              "title": "Start Date"
+            },
+            "description": "Filter logs from this timestamp using ISO8601 format"
+          },
+          {
+            "name": "end_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter logs up to this timestamp using ISO8601 format",
+              "title": "End Date"
+            },
+            "description": "Filter logs up to this timestamp using ISO8601 format"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "description": "Maximum number of log lines to return per container",
+              "default": 1000,
+              "title": "Limit"
+            },
+            "description": "Maximum number of log lines to return per container"
+          },
+          {
+            "name": "offset",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "description": "Number of log lines to skip per container",
+              "default": 0,
+              "title": "Offset"
+            },
+            "description": "Number of log lines to skip per container"
           }
         ],
         "responses": {
@@ -2919,6 +3057,277 @@
           }
         }
       }
+    },
+    "/netstats": {
+      "get": {
+        "tags": ["Logs"],
+        "summary": "Logs.Netstats.Get",
+        "description": "Retrieve network traffic statistics from netstats log events.",
+        "operationId": "logs_netstats_get_netstats_get",
+        "security": [
+          {
+            "JWT": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "analysis_id",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "uuid"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter by analysis UUID",
+              "title": "Analysis Id"
+            },
+            "description": "Filter by analysis UUID"
+          },
+          {
+            "name": "start_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter by start date using ISO8601 format",
+              "title": "Start Date"
+            },
+            "description": "Filter by start date using ISO8601 format"
+          },
+          {
+            "name": "end_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter by end date using ISO8601 format",
+              "title": "End Date"
+            },
+            "description": "Filter by end date using ISO8601 format"
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "integer",
+              "description": "Maximum number of raw log entries to return",
+              "default": 1000,
+              "title": "Limit"
+            },
+            "description": "Maximum number of raw log entries to return"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NetStatResponse"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/logs/query": {
+      "post": {
+        "tags": ["Logs"],
+        "summary": "Logs.Query.Raw",
+        "description": "Execute a raw LogQL query against VictoriaLogs. Admin only.",
+        "operationId": "logs_query_raw_logs_query_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/LogQLQueryRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/LogQLQueryResponse"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        },
+        "security": [
+          {
+            "JWT": []
+          }
+        ]
+      }
+    },
+    "/requests": {
+      "get": {
+        "tags": ["Logs"],
+        "summary": "Logs.Requests.Get",
+        "description": "Get total API request count and a per-endpoint breakdown grouped by HTTP method and path.",
+        "operationId": "logs_requests_get_requests_get",
+        "security": [
+          {
+            "JWT": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "start_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter requests from this timestamp using ISO8601 format",
+              "title": "Start Date"
+            },
+            "description": "Filter requests from this timestamp using ISO8601 format"
+          },
+          {
+            "name": "end_date",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "format": "date-time"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter requests up to this timestamp using ISO8601 format",
+              "title": "End Date"
+            },
+            "description": "Filter requests up to this timestamp using ISO8601 format"
+          },
+          {
+            "name": "endpoint",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter breakdown to paths starting with this prefix",
+              "title": "Endpoint"
+            },
+            "description": "Filter breakdown to paths starting with this prefix"
+          },
+          {
+            "name": "method",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Filter breakdown to a specific HTTP method (e.g. GET, POST, DELETE)",
+              "title": "Method"
+            },
+            "description": "Filter breakdown to a specific HTTP method (e.g. GET, POST, DELETE)"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiRequestCountResponse"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
     }
   },
   "components": {
@@ -3647,6 +4056,28 @@
         "title": "AnalysisStatus",
         "description": "Status report for an analysis from the PodOrchestrator"
       },
+      "ApiRequestCountResponse": {
+        "properties": {
+          "total": {
+            "type": "integer",
+            "title": "Total"
+          },
+          "data": {
+            "additionalProperties": {
+              "additionalProperties": {
+                "type": "integer"
+              },
+              "type": "object"
+            },
+            "type": "object",
+            "title": "Data"
+          }
+        },
+        "type": "object",
+        "required": ["total", "data"],
+        "title": "ApiRequestCountResponse",
+        "description": "Response for the API request count endpoint.\n\ndata maps endpoint path → {method: count, ..., \"total\": count}."
+      },
       "AutostartSettings": {
         "properties": {
           "enabled": {
@@ -5497,6 +5928,71 @@
         "title": "ListServices",
         "description": "Custom route list response model."
       },
+      "LogQLQueryRequest": {
+        "properties": {
+          "query": {
+            "type": "string",
+            "title": "Query"
+          },
+          "limit": {
+            "type": "integer",
+            "title": "Limit",
+            "default": 50
+          },
+          "offset": {
+            "type": "integer",
+            "title": "Offset",
+            "default": 0
+          },
+          "start": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Start"
+          },
+          "end": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "End"
+          }
+        },
+        "type": "object",
+        "required": ["query"],
+        "title": "LogQLQueryRequest",
+        "description": "Request body for a raw LogQL query."
+      },
+      "LogQLQueryResponse": {
+        "properties": {
+          "data": {
+            "items": {
+              "additionalProperties": true,
+              "type": "object"
+            },
+            "type": "array",
+            "title": "Data"
+          },
+          "meta": {
+            "$ref": "#/components/schemas/Meta"
+          }
+        },
+        "type": "object",
+        "required": ["data", "meta"],
+        "title": "LogQLQueryResponse",
+        "description": "Response for a raw LogQL query."
+      },
       "MasterImage": {
         "properties": {
           "id": {
@@ -5648,12 +6144,19 @@
             "title": "Limit"
           },
           "offset": {
-            "type": "integer",
+            "anyOf": [
+              {
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
             "title": "Offset"
           }
         },
         "type": "object",
-        "required": ["count", "total", "limit", "offset"],
+        "required": ["count", "total", "limit"],
         "title": "Meta",
         "description": "Event log metadata model."
       },
@@ -5709,6 +6212,89 @@
         "title": "MinioConfig",
         "description": "Credentials for accessing a private S3 bucket hosted on MinIO."
       },
+      "NetStatResponse": {
+        "properties": {
+          "data": {
+            "items": {
+              "$ref": "#/components/schemas/NetStatTotal"
+            },
+            "type": "array",
+            "title": "Data"
+          },
+          "meta": {
+            "$ref": "#/components/schemas/Meta"
+          }
+        },
+        "type": "object",
+        "required": ["data", "meta"],
+        "title": "NetStatResponse"
+      },
+      "NetStatRun": {
+        "properties": {
+          "timestamp": {
+            "type": "string",
+            "format": "date-time",
+            "title": "Timestamp"
+          },
+          "container": {
+            "type": "string",
+            "title": "Container"
+          },
+          "run_number": {
+            "type": "integer",
+            "title": "Run Number"
+          },
+          "pod": {
+            "type": "string",
+            "title": "Pod"
+          },
+          "bytes_in": {
+            "type": "integer",
+            "title": "Bytes In"
+          },
+          "bytes_out": {
+            "type": "integer",
+            "title": "Bytes Out"
+          }
+        },
+        "type": "object",
+        "required": [
+          "timestamp",
+          "container",
+          "run_number",
+          "pod",
+          "bytes_in",
+          "bytes_out"
+        ],
+        "title": "NetStatRun"
+      },
+      "NetStatTotal": {
+        "properties": {
+          "analysis_id": {
+            "type": "string",
+            "format": "uuid",
+            "title": "Analysis Id"
+          },
+          "bytes_in": {
+            "type": "integer",
+            "title": "Bytes In"
+          },
+          "bytes_out": {
+            "type": "integer",
+            "title": "Bytes Out"
+          },
+          "runs": {
+            "items": {
+              "$ref": "#/components/schemas/NetStatRun"
+            },
+            "type": "array",
+            "title": "Runs"
+          }
+        },
+        "type": "object",
+        "required": ["analysis_id", "bytes_in", "bytes_out", "runs"],
+        "title": "NetStatTotal"
+      },
       "Node": {
         "properties": {
           "external_name": {
diff --git a/server/routes/flame/api/auth/[...].ts b/server/routes/flame/api/auth/[...].ts
index cdef34d..306130a 100644
--- a/server/routes/flame/api/auth/[...].ts
+++ b/server/routes/flame/api/auth/[...].ts
@@ -36,6 +36,8 @@ function compileEndpoints() {
 function buildProvider() {
   const idpProvider = process.env.NUXT_PUBLIC_IDP_PROVIDER ?? "keycloak";
   const endPoints = compileEndpoints();
+  const clientIssuer =
+    process.env.NUXT_PUBLIC_IDP_ISSUER ?? "http://localhost:8080/realms/flame";
 
   const providers = [];
 
@@ -61,6 +63,39 @@ function buildProvider() {
       break;
     }
 
+    case "hub": {
+      const clientId = process.env.NUXT_IDP_CLIENT_ID ?? "node-ui";
+      const clientSecret = process.env.NUXT_IDP_CLIENT_SECRET;
+      const hubProvider = {
+        id: "hub",
+        name: "Hub",
+        type: "oauth",
+        idToken: false,
+        clientId: clientId,
+        clientSecret: clientSecret,
+        wellKnown: `${clientIssuer}/.well-known/openid-configuration`,
+        authorization: {
+          params: {
+            scope: "global",
+          },
+        },
+        profile(profile: {
+          id: string;
+          name: string | undefined;
+          first_name: string | undefined;
+          last_name: string | undefined;
+          display_name: string | undefined;
+        }) {
+          return {
+            id: profile.id,
+            name: profile.name ?? profile.display_name,
+          };
+        },
+      };
+      providers.push(hubProvider);
+      break;
+    }
+
     case "auth0": {
       const auth0Provider =
         // @ts-expect-error default is an option
@@ -111,10 +146,10 @@ async function refreshAccessToken(token: JWT) {
   const clientIssuer =
     process.env.NUXT_PUBLIC_IDP_ISSUER ?? "http://localhost:8080/realms/flame";
 
-  const internalEndpoint =
-    process.env.NUXT_PUBLIC_INTERNAL_KEYCLOAK_URL ?? clientIssuer;
-
-  const tokenEndpoint = `${internalEndpoint}/protocol/openid-connect/token`; // Assumes OIDC
+  const discovery = await fetch(
+    `${clientIssuer}/.well-known/openid-configuration`,
+  ).then((r) => r.json());
+  const tokenEndpoint: string = discovery.token_endpoint;
 
   const response = await fetch(tokenEndpoint, {
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -183,6 +218,20 @@ export default NuxtAuthHandler({
     /* on JWT token creation or mutation */
     async jwt({ token, account, user }) {
       if (account && user) {
+        if (account.type === "credentials") {
+          // CredentialsProvider (Hub password grant): tokens live on the user object
+          const u = user as {
+            access_token?: string;
+            refresh_token?: string;
+            expires_at?: number;
+          };
+          return {
+            ...token,
+            access_token: u.access_token,
+            expires_at: u.expires_at,
+            refresh_token: u.refresh_token,
+          };
+        }
         return {
           ...token,
           access_token: account.access_token,
diff --git a/test/components/analysis/logs/ContainerLogs.spec.ts b/test/components/analysis/logs/ContainerLogs.spec.ts
index 17098cc..f011ced 100644
--- a/test/components/analysis/logs/ContainerLogs.spec.ts
+++ b/test/components/analysis/logs/ContainerLogs.spec.ts
@@ -1,13 +1,19 @@
 import { defineComponent, ref } from "vue";
 import { flushPromises, mount } from "@vue/test-utils";
 import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+import { http, HttpResponse } from "msw";
 import ContainerLogs from "~/components/analysis/logs/ContainerLogs.vue";
 import { getAnalysisLogs } from "~/composables/useAPIFetch";
-import { fakeAnalysisId } from "@/test/mockapi/handlers";
+import {
+  fakeAnalysisId,
+  fakeAnalysisNodeId,
+} from "@/test/mockapi/handlers";
+import { testServer } from "@/test/mockapi/setup";
 
 vi.mock("vue-router", () => ({
   useRoute: () => ({
     params: { id: fakeAnalysisId },
+    query: { nodeId: fakeAnalysisNodeId },
   }),
 }));
 
@@ -59,6 +65,12 @@ describe("ContainerLogs.vue", () => {
   });
 
   test("Empty analysis logs", async () => {
+    testServer.use(
+      http.get(`/analysis-nodes/${fakeAnalysisNodeId}`, () =>
+        new HttpResponse(null, { status: 404 }),
+      ),
+    );
+
     vi.mocked(getAnalysisLogs).mockResolvedValue({
       data: ref(null),
       pending: ref(false),
diff --git a/test/mockapi/handlers.ts b/test/mockapi/handlers.ts
index 7f1db93..3603921 100644
--- a/test/mockapi/handlers.ts
+++ b/test/mockapi/handlers.ts
@@ -11,13 +11,17 @@ import {
   fakeParsedProjects,
 } from "../components/data-stores/constants";
 import { fakeProposalsResp } from "../components/projects/constants";
-import { fakeProjects } from "../components/analysis/constants";
+import {
+  fakeBaseAnalysisNode,
+  fakeProjects,
+} from "../components/analysis/constants";
 import { fakeEventResponse } from "../components/events/constants";
 
 export const fakeValidProposalId = "7f2f3b59-3b6d-4fb6-a900-2a4d5c2ea483";
 export const fakeInvalidProposalId = "15518efa-5146-4290-a7cb-95d27f41d991";
 
 export const fakeAnalysisId = "15518efa-5146-4290-a7cb-95d27f41d991";
+export const fakeAnalysisNodeId = "4c4b9b2e-85de-4319-8d68-bcc8247464eb";
 export const fakeMissingAnalysisId = "7f2f3b59-3b6d-4fb6-a900-2a4d5c2ea483";
 export const fakeBrokenAnalysisId = "ab1fbc92-3dc8-4bdd-9d51-3b571c2d7aaa";
 export const fakeInvalidRoleAnalysisId = "1a29aee7-538b-4a02-9fab-b184b1dcdc2a";
@@ -92,17 +96,19 @@ export const handlers = [
   // Analysis logs
   http.get(`/logs/${fakeAnalysisId}`, () => {
     return HttpResponse.json({
-      status: 200,
-      data: {
-        analysis: {
-          [fakeAnalysisId]: ["Starting FlameCoreSDK"],
-        },
-        nginx: {
-          [fakeAnalysisId]: [
-            "/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty",
-          ],
-        },
-      },
+      analysis_id: fakeAnalysisId,
+      run_number: 1,
+      analysis_logs: [
+        { timestamp: "2025-01-01T00:00:00Z", message: "Starting FlameCoreSDK" },
+      ],
+      nginx_logs: [],
+    });
+  }),
+
+  http.get(`/analysis-nodes/${fakeAnalysisNodeId}`, () => {
+    return HttpResponse.json({
+      ...fakeBaseAnalysisNode,
+      execution_status: "executing",
     });
   }),