cloving 1.3.0 → 1.4.0

package/dist/src/report-ready.js

@@ -0,0 +1,117 @@
+function boundaries(input, window) {
+    const times = [
+        window.start,
+        window.end,
+        ...(input.tickets ?? []).flatMap((ticket) => [
+            ...ticket.intervals.flatMap((interval) => [
+                interval.start,
+                interval.end ?? window.end,
+            ]),
+            ...ticket.dependencies.flatMap((dependency) => dependency.closedAt === null ? [] : [dependency.closedAt]),
+        ]),
+        ...(input.flow?.runs ?? []).flatMap((run) => [
+            run.start,
+            run.end ?? window.end,
+        ]),
+    ];
+    return [...new Set(times)]
+        .filter((at) => at >= window.start && at <= window.end)
+        .toSorted((a, b) => a - b);
+}
+function readyAt(ticket, at) {
+    return ticket.intervals.some((interval) => interval.start <= at && (interval.end === null || interval.end > at));
+}
+function blockedAt(ticket, at) {
+    return ticket.dependencies.some((dependency) => dependency.closedAt === null || dependency.closedAt > at);
+}
+function knownQueue(flow, window) {
+    return (flow?.queue != null &&
+        flow.runs !== null &&
+        flow.runs.every((run) => run.workflowId !== null ||
+            run.start >= window.end ||
+            (run.end !== null && run.end <= window.start)));
+}
+function addHours(waits, input) {
+    waits.set(input.ticket.issue, (waits.get(input.ticket.issue) ?? 0) + input.hours);
+}
+function activeQueueRuns(flow, at) {
+    return (flow?.runs ?? []).filter((run) => run.workflowId === flow?.queue?.workflowId &&
+        run.start <= at &&
+        (run.end === null || run.end > at));
+}
+function addSlice(summary, input) {
+    const ready = input.tickets.filter((ticket) => readyAt(ticket, input.at));
+    const eligible = ready.filter((ticket) => !blockedAt(ticket, input.at));
+    for (const ticket of ready.filter((ticket) => blockedAt(ticket, input.at)))
+        addHours(summary.dependency, { ticket, hours: input.hours });
+    const queue = input.flow?.queue;
+    if (queue == null || eligible.length === 0)
+        return;
+    const active = activeQueueRuns(input.flow, input.at);
+    if (active.length < queue.lanes) {
+        summary.idle += input.hours;
+        for (const ticket of eligible)
+            summary.idleIssues.add(ticket.issue);
+        for (const run of active)
+            summary.idleRuns.add(run.runId);
+        return;
+    }
+    for (const ticket of eligible)
+        addHours(summary.noLane, { ticket, hours: input.hours });
+    for (const run of active)
+        summary.fullRuns.add(run.runId);
+}
+export function reportReadyData(input, window) {
+    const tickets = input.tickets;
+    if (tickets === null)
+        return { dependency: null, noLane: null, idle: null };
+    const times = boundaries(input, window);
+    const summary = {
+        dependency: new Map(),
+        noLane: new Map(),
+        idleIssues: new Set(),
+        idleRuns: new Set(),
+        fullRuns: new Set(),
+        idle: 0,
+    };
+    for (let index = 0; index < times.length - 1; index += 1) {
+        const at = times[index] ?? window.end;
+        const hours = ((times[index + 1] ?? at) - at) / 3_600_000;
+        addSlice(summary, { tickets, flow: input.flow, at, hours });
+    }
+    const known = knownQueue(input.flow, window);
+    return {
+        dependency: waitData({ tickets, waits: summary.dependency }, window),
+        noLane: known
+            ? waitData({ tickets, waits: summary.noLane, runIds: [...summary.fullRuns] }, window)
+            : null,
+        idle: known
+            ? [
+                {
+                    at: window.start,
+                    value: summary.idle,
+                    evidence: {
+                        issues: [...summary.idleIssues],
+                        runIds: [...summary.idleRuns],
+                    },
+                },
+            ]
+            : null,
+    };
+}
+function waitData(input, window) {
+    const data = input.tickets
+        .filter((ticket) => input.waits.has(ticket.issue))
+        .map((ticket) => ({
+        at: window.start,
+        value: input.waits.get(ticket.issue) ?? 0,
+        evidence: {
+            issue: ticket.issue,
+            dependencies: ticket.dependencies.map((dependency) => dependency.issue),
+            ...(input.runIds === undefined ? {} : { runIds: input.runIds }),
+        },
+    }));
+    return data.length === 0
+        ? [{ at: window.start, value: 0, evidence: { issues: [] } }]
+        : data;
+}

package/dist/src/report-statistics.d.ts

@@ -1,4 +1,5 @@
 export interface ReportDatum {
+    readonly key?: string;
     readonly at: number;
     readonly value: number | null;
     readonly evidence: Readonly<Record<string, unknown>>;
@@ -11,7 +12,7 @@ export interface ReportWindow {
 interface MetricInput {
     readonly data: readonly ReportDatum[] | null;
     readonly window: ReportWindow;
-    readonly aggregation: "count" | "median";
+    readonly aggregation: "count" | "median" | "mean" | "distinct";
 }
 export declare function reportMedian(values: readonly number[]): number | null;
 export declare function reportMetric(input: MetricInput): {

package/dist/src/report-statistics.js

@@ -13,7 +13,11 @@ function aggregate(data, aggregation) {
     if (data.some((datum) => datum.value === null))
         return null;
     const values = data.flatMap((datum) => datum.value === null ? [] : [datum.value]);
-    return aggregation === "count"
+    if (aggregation === "mean")
+        return values.length === 0
+            ? null
+            : values.reduce((sum, value) => sum + value, 0) / values.length;
+    return aggregation === "count" || aggregation === "distinct"
         ? values.reduce((sum, value) => sum + value, 0)
         : reportMedian(values);
 }
@@ -27,7 +31,7 @@ function baseline(input) {
         const start = end - day;
         if (origin === null || origin > start || input.data === null)
             continue;
-        const data = selected(input.data, { start, end });
+        const data = metricData(input, { start, end });
         const value = aggregate(data, input.aggregation);
         if (value === null)
             continue;
@@ -49,9 +53,9 @@ function historySummary(samples) {
     return { history: "available", days: samples.length, median, band };
 }
 export function reportMetric(input) {
-    const data = selected(input.data ?? [], input.window);
+    const data = metricData(input, input.window);
     const value = input.data === null ? null : aggregate(data, input.aggregation);
-    const comparisonValue = value !== null && input.aggregation === "count"
+    const comparisonValue = value !== null && ["count", "distinct"].includes(input.aggregation)
         ? (value * 86_400_000) / (input.window.end - input.window.start)
         : value;
     const history = baseline(input);
@@ -68,3 +72,35 @@ export function reportMetric(input) {
 export function outsideReportBand(value, band) {
     return (value !== null && band !== null && (value < band.low || value > band.high));
 }
+function metricData(input, window) {
+    const data = selected(input.data ?? [], window);
+    if (input.aggregation !== "distinct")
+        return data;
+    const groups = new Map();
+    for (const datum of data) {
+        if (datum.key === undefined)
+            throw new Error("missing-report-datum-key");
+        const previous = groups.get(datum.key);
+        groups.set(datum.key, previous === undefined
+            ? datum
+            : {
+                ...datum,
+                evidence: combinedEvidence(previous.evidence, datum.evidence),
+            });
+    }
+    return [...groups.values()];
+}
+function combinedEvidence(left, right) {
+    return Object.fromEntries(Object.entries(right).map(([key, value]) => {
+        const earlier = left[key];
+        return [
+            key,
+            unknownList(earlier) && unknownList(value)
+                ? [...new Set([...earlier, ...value])]
+                : value,
+        ];
+    }));
+}
+function unknownList(value) {
+    return Array.isArray(value);
+}