@hot-updater/console 1.1.3 → 1.1.5

package/src/lib/release-adoption-api.ts

@@ -4,10 +4,11 @@ import { insightsPeriodEnd, recoveryWindows } from "./insights-recovery";
 import type { InsightsWindow } from "./insights-rpc";
 import type { HealthChart } from "./insights-search";
 import {
-  DEFAULT_ADOPTION_RELEASES,
   type AdoptionRelease,
   type BundleEventType,
   type BundleEventsSeries,
+  defaultAdoptionReleases,
+  type HealthPlatform,
   MAX_ADOPTION_RELEASES,
 } from "./release-adoption";
 import {
@@ -39,7 +40,10 @@ export type ReleaseHealthState = {
     readonly durationMs: number;
     readonly intervalMs: number;
   };
-  /** The newest bundle deployments, newest first; undefined while loading. */
+  /**
+   * The newest bundle deployments and the newest enabled ones, newest
+   * first; undefined while loading.
+   */
   readonly candidates: readonly AdoptionRelease[] | undefined;
   /** The compared bundles; undefined until they are known. */
   readonly releases: readonly ComparedBundle[] | undefined;
@@ -64,10 +68,10 @@ export function useReleaseHealth({
   focusReleaseId,
   chart,
 }: {
-  readonly platform: "ios" | "android";
+  readonly platform: HealthPlatform;
   readonly channel: string;
   readonly window: InsightsWindow;
-  /** Chosen bundles; undefined, the focus and its previous, or the newest. */
+  /** Chosen bundles; undefined, the focus and its previous, or the live ones. */
   readonly releaseIds: readonly string[] | undefined;
   readonly focusReleaseId: string | undefined;
   readonly chart: HealthChart;
@@ -83,23 +87,14 @@ export function useReleaseHealth({
     staleTime: 5 * 60_000,
   });
   const candidates = candidatesQuery.data;
-  const focusIndex =
-    focusReleaseId === undefined || candidates === undefined
-      ? -1
-      : candidates.findIndex((release) => release.releaseId === focusReleaseId);
-  // A focus among the newest has its previous bundle there too, unless it is
-  // the oldest of them.
+  // A focus and the bundle deployed before it on its platform.
   const focusQuery = useQuery({
     queryKey: ["insights", "adoption-release", scope, focusReleaseId, true],
     queryFn: () =>
       getAdoptionReleaseRpc({
         data: { ...scope, releaseId: focusReleaseId!, withPrevious: true },
       }),
-    enabled:
-      releaseIds === undefined &&
-      focusReleaseId !== undefined &&
-      candidates !== undefined &&
-      (focusIndex === -1 || focusIndex === candidates.length - 1),
+    enabled: releaseIds === undefined && focusReleaseId !== undefined,
     staleTime: Number.POSITIVE_INFINITY,
   });
   const known = new Map<string, AdoptionRelease>();
@@ -110,28 +105,24 @@ export function useReleaseHealth({
     ...(candidates ?? []),
   ])
     known.set(release.releaseId, release);
-  const newest = (list: readonly AdoptionRelease[]) =>
-    list
-      .slice(0, DEFAULT_ADOPTION_RELEASES)
-      .map((release) => release.releaseId);
+  const live = (list: readonly AdoptionRelease[]) =>
+    defaultAdoptionReleases(list, platform);
   const chosen: readonly string[] | undefined =
     releaseIds !== undefined
       ? releaseIds.slice(0, MAX_ADOPTION_RELEASES)
       : candidates === undefined
         ? undefined
         : focusReleaseId === undefined
-          ? newest(candidates)
-          : focusIndex !== -1 && focusIndex < candidates.length - 1
-            ? [focusReleaseId, candidates[focusIndex + 1]!.releaseId]
-            : focusQuery.data === undefined
-              ? undefined
-              : focusQuery.data.release === null
-                ? // A focus that is no bundle of this scope: the newest.
-                  newest(candidates)
-                : [
-                    focusQuery.data.release.releaseId,
-                    focusQuery.data.previous?.releaseId,
-                  ].filter((id) => id !== undefined);
+          ? live(candidates)
+          : focusQuery.data === undefined
+            ? undefined
+            : focusQuery.data.release === null
+              ? // A focus that is no bundle of this scope: the live ones.
+                live(candidates)
+              : [
+                  focusQuery.data.release.releaseId,
+                  focusQuery.data.previous?.releaseId,
+                ].filter((id) => id !== undefined);
   // A chosen bundle the newest leave out, as from a copied link.
   const unknown = (chosen ?? []).filter(
     (releaseId) => !known.has(releaseId) && releaseId !== focusReleaseId,
@@ -159,7 +150,8 @@ export function useReleaseHealth({
   const seriesQueries = useQueries({
     queries: reads.map(({ release, type }) => {
       const data = {
-        ...scope,
+        platform: release.platform,
+        channel,
         window,
         endMs,
         bundleId: release.bundleId,

package/src/lib/release-adoption.ts

@@ -6,28 +6,37 @@ import type { InsightsWindow } from "./insights-rpc";
  * Each is a read of its counts over the period, and four hues stay apart.
  */
 export const MAX_ADOPTION_RELEASES = 4;
-/** Bundles Release health compares when none are chosen: the newest two. */
+/**
+ * Bundles Release health compares when none are chosen: the two newest live
+ * ones of one platform, or the newest live one of each.
+ */
 export const DEFAULT_ADOPTION_RELEASES = 2;
-/** Bundle deployments Release health offers to add. */
+/** Bundle deployments of each platform Release health offers to add. */
 export const ADOPTION_CANDIDATES = 10;
 /** A crash rate at which Release health recommends rolling a bundle back. */
 export const CRASH_RATE_THRESHOLD = 0.05;
 /** Attempts below which a crash rate is too noisy to recommend anything. */
 export const CRASH_MIN_ATTEMPTS = 20;
 
+/** Release health's platforms: one, or both side by side. */
+export type HealthPlatform = "all" | "ios" | "android";
+
 /** A deployed bundle, as Release health labels and rolls it back. */
 export type AdoptionRelease = {
   readonly releaseId: string;
   readonly bundleId: string;
+  readonly platform: "ios" | "android";
   readonly deployedAtMs: number;
   readonly targetAppVersion: string | null;
   readonly enabled: boolean;
+  /** Whether a device can get it now: its scope's catalog still serves it. */
+  readonly live: boolean;
   readonly revision: number;
 };
 
-/** A channel and platform's newest bundle deployments. */
+/** A channel's newest bundle deployments, of one platform or both. */
 export type AdoptionReleasesInput = {
-  readonly platform: "ios" | "android";
+  readonly platform: HealthPlatform;
   readonly channel: string;
 };
 
@@ -51,7 +60,10 @@ export type AdoptionReleaseResult = {
 export type BundleEventType = "DOWNLOADED" | "LAUNCHED" | "RECOVERED";
 
 /** One bundle's reports of one type over the period that ends at `endMs`. */
-export type BundleEventsInput = AdoptionReleasesInput & {
+export type BundleEventsInput = {
+  /** The bundle's own platform. */
+  readonly platform: "ios" | "android";
+  readonly channel: string;
   readonly window: InsightsWindow;
   /** The end of an hour; every bundle of one chart reads the same one. */
   readonly endMs: number;
@@ -90,7 +102,9 @@ export function readAdoptionReleasesInput(
 ): AdoptionReleasesInput {
   if (
     !input ||
-    (input.platform !== "ios" && input.platform !== "android") ||
+    (input.platform !== "all" &&
+      input.platform !== "ios" &&
+      input.platform !== "android") ||
     !isText(input.channel)
   )
     invalid();
@@ -117,8 +131,9 @@ export function readAdoptionReleaseInput(
 export function readBundleEventsInput(
   input: BundleEventsInput,
 ): BundleEventsInput {
-  const scope = readAdoptionReleasesInput(input);
+  const { platform, channel } = readAdoptionReleasesInput(input);
   if (
+    platform === "all" ||
     !Object.hasOwn(recoveryWindows, input.window) ||
     typeof input.endMs !== "number" ||
     !Number.isSafeInteger(input.endMs) ||
@@ -131,7 +146,8 @@ export function readBundleEventsInput(
   )
     invalid();
   return {
-    ...scope,
+    platform: platform as BundleEventsInput["platform"],
+    channel,
     window: input.window,
     endMs: input.endMs,
     bundleId: input.bundleId,
@@ -149,6 +165,27 @@ export const crashRateOf = (launched: number, recovered: number) => {
   return { attempts, rate: attempts === 0 ? 0 : recovered / attempts };
 };
 
+/**
+ * The bundles Release health compares when none are chosen, from the
+ * candidates newest first: the two newest live bundles of one platform, or
+ * the newest live one of each; without any live one, the newest two.
+ */
+export const defaultAdoptionReleases = (
+  candidates: readonly AdoptionRelease[],
+  platform: HealthPlatform,
+): readonly string[] => {
+  const live = (
+    platform === "all" ? (["ios", "android"] as const) : [platform]
+  ).flatMap((each) =>
+    candidates
+      .filter((release) => release.platform === each && release.live)
+      .slice(0, platform === "all" ? 1 : DEFAULT_ADOPTION_RELEASES),
+  );
+  return (live.length > 0 ? live : candidates)
+    .slice(0, DEFAULT_ADOPTION_RELEASES)
+    .map((release) => release.releaseId);
+};
+
 /** Whether a bundle's crashes call for rolling it back. */
 export const recommendsRollback = (
   release: Pick<AdoptionRelease, "enabled">,

package/src/lib/server/failureReports.ts

@@ -36,7 +36,7 @@ export async function listFailureReports(
       ...page.data.filter(
         (event) =>
           event.type === "UPDATE_FAILED" &&
-          event.platform === input.platform &&
+          (input.platform === "all" || event.platform === input.platform) &&
           event.channel === input.channel &&
           (input.releaseId === undefined ||
             (event.failure?.stage !== "check" &&

package/src/lib/server/releaseAdoption.ts

@@ -8,6 +8,7 @@ import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
 import {
   ADOPTION_CANDIDATES,
   type AdoptionRelease,
+  type HealthPlatform,
   type AdoptionReleaseInput,
   type AdoptionReleaseResult,
   type AdoptionReleasesInput,
@@ -17,31 +18,55 @@ import {
   readAdoptionReleasesInput,
   readBundleEventsInput,
 } from "../release-adoption";
+import { addReleaseReachability } from "./releaseReachability";
 
 type ReleaseReads = Pick<
   HotUpdaterCoreApi,
-  "findChannelByName" | "getRelease" | "listReleases"
+  "findChannelByName" | "getRelease" | "getReleaseCatalogRow" | "listReleases"
 >;
 
 /** Rows read past a focused release to find the bundle before it. */
 const PREVIOUS_ROWS = 4;
 
-const labelOf = (release: ReleaseRow): AdoptionRelease => ({
-  releaseId: release.id,
-  bundleId: release.bundle_id!,
-  deployedAtMs: release.created_at_ms,
-  targetAppVersion: release.target_app_version,
-  enabled: release.enabled,
-  revision: release.revision,
-});
+const platformsOf = (platform: HealthPlatform) =>
+  platform === "all" ? (["ios", "android"] as const) : [platform];
 
-// A release without a bundle has nothing to apply.
-const bundles = (releases: readonly ReleaseRow[]) =>
-  releases.filter((release) => release.bundle_id).map(labelOf);
+/**
+ * Labels the releases that have a bundle, a release without one having
+ * nothing to apply. A bundle is live when its scope's catalog still serves
+ * it: one catalog read per scope of the enabled ones.
+ */
+const labelled = async (
+  core: Pick<ReleaseReads, "getReleaseCatalogRow">,
+  releases: readonly ReleaseRow[],
+): Promise<AdoptionRelease[]> => {
+  const bundles = releases.filter((release) => release.bundle_id);
+  const live = new Set(
+    (
+      await addReleaseReachability(
+        core,
+        bundles.filter((release) => release.enabled),
+      )
+    )
+      .filter((release) => !release.currentlyUnreachable)
+      .map((release) => release.id),
+  );
+  return bundles.map((release) => ({
+    releaseId: release.id,
+    bundleId: release.bundle_id!,
+    platform: release.platform,
+    deployedAtMs: release.created_at_ms,
+    targetAppVersion: release.target_app_version,
+    enabled: release.enabled,
+    live: live.has(release.id),
+    revision: release.revision,
+  }));
+};
 
 /**
- * The newest bundle deployments of a channel and platform, newest first: one
- * read of the channel and one of its newest releases.
+ * A channel's newest bundle deployments, of one platform or both, newest
+ * first: per platform, its newest releases and its newest enabled ones, so
+ * a live bundle older than the newest still shows.
  */
 export async function listAdoptionReleases(
   core: ReleaseReads,
@@ -50,18 +75,37 @@ export async function listAdoptionReleases(
   const { platform, channel } = readAdoptionReleasesInput(input);
   const row = await core.findChannelByName(channel);
   if (row === null) return [];
-  return bundles(
-    await core.listReleases({
-      filter: { kind: "channelPlatform", channelId: row.id, platform },
-      order: "desc",
-      limit: ADOPTION_CANDIDATES,
-    }),
+  const lists = await Promise.all(
+    platformsOf(platform).flatMap((each) =>
+      [{}, { enabled: true }].map((enabled) =>
+        core.listReleases({
+          filter: {
+            kind: "channelPlatform",
+            channelId: row.id,
+            platform: each,
+            ...enabled,
+          },
+          order: "desc",
+          limit: ADOPTION_CANDIDATES,
+        }),
+      ),
+    ),
+  );
+  const releases = new Map(
+    lists.flat().map((release) => [release.id, release]),
+  );
+  return labelled(
+    core,
+    [...releases.values()].sort(
+      (left, right) => right.created_at_ms - left.created_at_ms,
+    ),
   );
 }
 
 /**
- * One bundle deployment of the channel and platform, for a focus the newest
- * ones leave out, and with `withPrevious` the bundle deployed before it.
+ * One bundle deployment of the channel, for a focus the newest ones leave
+ * out, and with `withPrevious` the bundle deployed before it on its
+ * platform.
  */
 export async function getAdoptionRelease(
   core: ReleaseReads,
@@ -77,19 +121,24 @@ export async function getAdoptionRelease(
     row === null ||
     release === null ||
     !release.bundle_id ||
-    release.platform !== platform ||
+    (platform !== "all" && release.platform !== platform) ||
     release.channel_id !== row.id
   )
     return withPrevious ? { release: null, previous: null } : { release: null };
-  if (!withPrevious) return { release: labelOf(release) };
+  if (!withPrevious) return { release: (await labelled(core, [release]))[0]! };
   // Newest first, `after` a release lists older ones.
   const older = await core.listReleases({
-    filter: { kind: "channelPlatform", channelId: row.id, platform },
+    filter: {
+      kind: "channelPlatform",
+      channelId: row.id,
+      platform: release.platform,
+    },
     order: "desc",
     after: release.id,
     limit: PREVIOUS_ROWS,
   });
-  return { release: labelOf(release), previous: bundles(older)[0] ?? null };
+  const [label, previous] = await labelled(core, [release, ...older]);
+  return { release: label!, previous: previous ?? null };
 }
 
 /**

package/src/lib/server/updateFailures.ts

@@ -1,4 +1,8 @@
-import type { InsightsReads } from "@hot-updater/server/plugins";
+import type { HotUpdaterCoreApi } from "@hot-updater/plugin-core";
+import type {
+  InsightsReads,
+  InsightsUpdateFailures,
+} from "@hot-updater/server/plugins";
 
 import {
   checkFailureRate,
@@ -9,11 +13,111 @@ import {
 } from "../insights-failures";
 import { insightsPeriodEnd, recoveryWindows } from "../insights-recovery";
 
-/** A release's or a channel's update failures over a period that ends with the current hour. */
+const total = (
+  reports: readonly InsightsUpdateFailures[],
+  count: (report: InsightsUpdateFailures) => number,
+) => reports.reduce((sum, report) => sum + count(report), 0);
+
+/** Counts summed by key, most first, then in key order. */
+const summed = <T extends { readonly events: number }>(
+  rows: readonly T[],
+  keyOf: (row: T) => string,
+  merge: (first: T, rows: readonly T[]) => T,
+): T[] => {
+  const groups = new Map<string, T[]>();
+  for (const row of rows) {
+    const key = keyOf(row);
+    groups.set(key, [...(groups.get(key) ?? []), row]);
+  }
+  return [...groups]
+    .map(([key, group]) => ({ key, row: merge(group[0]!, group) }))
+    .sort(
+      (left, right) =>
+        right.row.events - left.row.events ||
+        (left.key < right.key ? -1 : left.key > right.key ? 1 : 0),
+    )
+    .map(({ row }) => row);
+};
+
+/**
+ * Both platforms' failures as one report. An installation runs on one
+ * platform, so its counts and installation estimates add up; the period is
+ * complete only where both are.
+ */
+export function mergeUpdateFailures(
+  reports: readonly InsightsUpdateFailures[],
+): InsightsUpdateFailures {
+  if (reports.length === 1) return reports[0]!;
+  const sinceMs = reports.map(({ coverage }) => coverage.sinceMs);
+  const latestSince = sinceMs.includes(null)
+    ? null
+    : Math.max(...(sinceMs as number[]));
+  const checks = reports.flatMap((report) =>
+    report.checks ? [report.checks] : [],
+  );
+  const breakdowns = reports.flatMap((report) => report.breakdown ?? []);
+  return {
+    coverage:
+      latestSince !== null &&
+      reports.every(({ coverage }) => coverage.kind === "complete")
+        ? { kind: "complete", sinceMs: latestSince }
+        : { kind: "partial", sinceMs: latestSince },
+    measuredAtMs: Math.min(...reports.map((report) => report.measuredAtMs)),
+    failedUpdates: total(reports, (report) => report.failedUpdates),
+    failedInstallations: total(reports, (report) => report.failedInstallations),
+    downloads: total(reports, (report) => report.downloads),
+    patchDownloads: total(reports, (report) => report.patchDownloads),
+    patchFallbacks: total(reports, (report) => report.patchFallbacks),
+    ...(checks.length === 0
+      ? {}
+      : {
+          checks: {
+            failures: checks.reduce((sum, row) => sum + row.failures, 0),
+            failedInstallations: checks.reduce(
+              (sum, row) => sum + row.failedInstallations,
+              0,
+            ),
+            activeInstallations: checks.reduce(
+              (sum, row) => sum + row.activeInstallations,
+              0,
+            ),
+          },
+        }),
+    ...(reports.some((report) => report.breakdown)
+      ? {
+          breakdown: summed(
+            breakdowns,
+            ({ stage, reason }) => JSON.stringify([stage, reason]),
+            (first, group) => ({
+              stage: first.stage,
+              reason: first.reason,
+              events: group.reduce((sum, row) => sum + row.events, 0),
+              details: summed(
+                group.flatMap((row) => row.details),
+                ({ resource, httpStatus, originCode, transport }) =>
+                  JSON.stringify([resource, httpStatus, originCode, transport]),
+                (detail, details) => ({
+                  ...detail,
+                  events: details.reduce((sum, row) => sum + row.events, 0),
+                }),
+              ),
+            }),
+          ),
+        }
+      : {}),
+  };
+}
+
+/**
+ * A release's or a channel's update failures over a period that ends with
+ * the current hour. Both platforms read each and merge, except a release's,
+ * which reads only the platform it was deployed to.
+ */
 export async function getUpdateFailuresReport(
   reads: Pick<InsightsReads, "getUpdateFailures">,
   input: UpdateFailuresInput,
   now = Date.now(),
+  releases?: Pick<HotUpdaterCoreApi, "getRelease">,
 ): Promise<UpdateFailuresReport> {
   readUpdateFailuresInput(input);
   const end = insightsPeriodEnd(now);
@@ -25,10 +129,32 @@ export async function getUpdateFailuresReport(
           end,
         };
   const scope = {
-    platform: input.platform,
     channel: input.channel,
     ...(input.releaseId === undefined ? {} : { releaseId: input.releaseId }),
   };
+  const release =
+    input.platform === "all" && input.releaseId !== undefined && releases
+      ? await releases.getRelease(input.releaseId)
+      : null;
+  const platforms =
+    input.platform !== "all"
+      ? [input.platform]
+      : release
+        ? [release.platform]
+        : (["ios", "android"] as const);
+  // Both platforms: one read of each, merged.
+  const read = async (range: typeof timeRange) =>
+    mergeUpdateFailures(
+      await Promise.all(
+        platforms.map((platform) =>
+          reads.getUpdateFailures({
+            ...scope,
+            platform,
+            ...(range === undefined ? {} : { timeRange: range }),
+          }),
+        ),
+      ),
+    );
   const previousRange =
     timeRange && timeRange.start >= timeRange.end - timeRange.start
       ? {
@@ -37,13 +163,8 @@ export async function getUpdateFailuresReport(
         }
       : undefined;
   const [failures, previous] = await Promise.all([
-    reads.getUpdateFailures({
-      ...scope,
-      ...(timeRange === undefined ? {} : { timeRange }),
-    }),
-    previousRange === undefined
-      ? undefined
-      : reads.getUpdateFailures({ ...scope, timeRange: previousRange }),
+    read(timeRange),
+    previousRange === undefined ? undefined : read(previousRange),
   ]);
   return {
     ...failures,