sparkforensics-cli 0.1.0

package/vendor-core/wall-clock.js

@@ -0,0 +1,36 @@
+export function mergeIntervals(intervals                    )                     {
+  if (intervals.length === 0) return [];
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  const out                     = [[sorted[0][0], sorted[0][1]]];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = out[out.length - 1];
+    const cur = sorted[i];
+    if (cur[0] <= last[1]) last[1] = Math.max(last[1], cur[1]);
+    else out.push([cur[0], cur[1]]);
+  }
+  return out;
+}
+
+export function computeWallClock(app                                                             , stages                                                           )                                                                                     {
+  const start = app?.startTime ?? 0;
+  const stageList = [...stages.values()].filter(s => s.submittedAt != null && s.completedAt != null);
+  const intervals = stageList.map(s => [s.submittedAt          , s.completedAt          ]);
+  const explicitEnd = app?.endTime ?? null;
+  const end = explicitEnd ?? (intervals.length > 0 ? intervals.reduce((m, i) => Math.max(m, i[1]), -Infinity) : start);
+  const total = Math.max(0, end - start);
+
+  if (intervals.length === 0) {
+    return { total, startup: total, stagesActive: 0, gaps: 0, idle: 0 };
+  }
+
+  const merged = mergeIntervals(intervals                      );
+  const stagesActive = merged.reduce((sum, [a, b]) => sum + (b - a), 0);
+  const firstStageStart = merged[0][0];
+  const startup = Math.max(0, firstStageStart - start);
+  let gaps = 0;
+  for (let i = 1; i < merged.length; i++) gaps += merged[i][0] - merged[i - 1][1];
+  const lastStageEnd = merged[merged.length - 1][1];
+  const idle = Math.max(0, end - lastStageEnd);
+
+  return { total, startup, stagesActive, gaps, idle };
+}

package/vendor-core/wasted-core-hours.js

@@ -0,0 +1,68 @@
+// Wasted core-hours summary (ELV-023). Pure, worker-agnostic reducer over the
+// same inputs the memoryUtilization detector's idle-cores math uses
+// (src/detectors.js ~608-619): capacity core-time vs. core-time that actually
+// ran tasks. No new detector, no new tag: this only feeds a report widget.
+
+import { computeTotalCores } from './core-count.js';
+
+export const MS_PER_CORE_HOUR         = 3.6e6;
+const TOP_N = 5;
+
+                                 
+                                
+                                 
+                                 
+                            
+                                                        
+ 
+
+const EMPTY                        = {
+  totalCoreHours: null,
+  usefulCoreHours: null,
+  wastedCoreHours: null,
+  totalCores: null,
+  topStages: [],
+};
+
+                         
+                      
+                                                              
+ 
+
+// `app` and `runAggregates` are typed nullable (beyond the brief's bare
+// signature) because real callers do pass null here (see
+// tests/wasted-core-hours.test.js and the WastedCoreHours widget, where
+// appModel.app is SparkAppInfo | null before parsing completes); the
+// optional-chaining/`!runAggregates` guard below already tolerated this at
+// runtime. `resources` is likewise added to app's shape (not in the brief's
+// signature) so the pass-through to computeTotalCores type-checks; real app
+// objects always carry it alongside startTime/endTime.
+export function computeWastedCoreHours(
+  app                                                                                                       ,
+  executorsAdded                                             = [],
+  runAggregates                      ,
+)                        {
+  // Nullish (not falsy) guard on times: a literal startTime:0 is valid.
+  if (!runAggregates || app?.startTime == null || app?.endTime == null) return EMPTY;
+  const appDurationMs = app.endTime - app.startTime;
+  if (appDurationMs <= 0) return EMPTY;
+
+  // Total cores: prefer real Executor-Added Total Cores, else peakExecutors ×
+  // configured cores (same fallback as the memoryUtilization detector).
+  const totalCores = computeTotalCores(app, executorsAdded);
+  if (totalCores <= 0) return EMPTY;
+
+  const totalCoreHours = (totalCores * appDurationMs) / MS_PER_CORE_HOUR;
+  const usefulCoreHours = (runAggregates.busyCoreMs ?? 0) / MS_PER_CORE_HOUR;
+  // Clamp: totalCores can be a fallback estimate while busyCoreMs is measured
+  // from task events, so the difference can dip below zero (same guard as
+  // src/efficiency-model.js).
+  const wastedCoreHours = Math.max(0, totalCoreHours - usefulCoreHours);
+
+  const topStages = Object.entries(runAggregates.perStage ?? {})
+    .map(([stageId, s]) => ({ stageId: Number(stageId), coreMs: s?.totalTaskDurationSum ?? 0 }))
+    .sort((a, b) => b.coreMs - a.coreMs)
+    .slice(0, TOP_N);
+
+  return { totalCoreHours, usefulCoreHours, wastedCoreHours, totalCores, topStages };
+}