iOS プレリリース版の端末を計測から外して失敗した記録 — 除外ではなく分離するトラック設計

// src/telemetry/osTrack.ts
import { Platform } from "react-native";
 
export type OsTrack = "ga" | "prerelease" | "unknown";
 
export type GaBaseline = { ios: number; android: number; updatedAt: string };
 
/**
 * 端末 OS のメジャーバージョンを数値で返します。
 * iOS   : Platform.Version は "27.0" のような文字列
 * Android: Platform.Version は 36 のような数値（API レベル）
 * 同じプロパティで型が異なるため、必ず正規化してから比較します。
 */
export function parseOsMajor(): number | null {
  const raw = Platform.Version;
  if (typeof raw === "number") return raw;
  const major = Number.parseInt(String(raw), 10);
  return Number.isFinite(major) ? major : null;
}
 
export function resolveOsTrack(baseline: GaBaseline | null): OsTrack {
  const major = parseOsMajor();
 
  // 判定材料が欠けたときは prerelease に倒しません。
  // 倒すと基準値の更新が遅れた瞬間に GA トラックが空になります。
  if (major === null || baseline === null) return "unknown";
 
  const knownGa = Platform.OS === "ios" ? baseline.ios : baseline.android;
  return major > knownGa ? "prerelease" : "ga";
}

// src/telemetry/gaBaseline.ts
import AsyncStorage from "@react-native-async-storage/async-storage";
import type { GaBaseline } from "./osTrack";
 
const CACHE_KEY = "telemetry.gaBaseline.v1";
const ENDPOINT = "https://config.example.com/ga-baseline.json";
const TIMEOUT_MS = 2500;
 
// ビルド時点で判明している正式リリース版のメジャー。
// リモートも キャッシュも駄目なときの最終地点です。
const BUNDLED: GaBaseline = { ios: 26, android: 36, updatedAt: "2026-07-01" };
 
function isValid(v: unknown): v is GaBaseline {
  const b = v as Partial<GaBaseline> | null;
  return (
    !!b &&
    typeof b.ios === "number" &&
    typeof b.android === "number" &&
    b.ios > 0 &&
    b.android > 0
  );
}
 
export async function loadGaBaseline(): Promise<GaBaseline> {
  let fallback: GaBaseline = BUNDLED;
  try {
    const cached = await AsyncStorage.getItem(CACHE_KEY);
    const parsed = cached ? JSON.parse(cached) : null;
    if (isValid(parsed)) fallback = parsed;
  } catch {
    // キャッシュが壊れていても起動は止めません
  }
 
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
  try {
    const res = await fetch(ENDPOINT, { signal: controller.signal });
    if (!res.ok) throw new Error(`ga-baseline http ${res.status}`);
    const next: unknown = await res.json();
    if (!isValid(next)) throw new Error("ga-baseline shape mismatch");
    await AsyncStorage.setItem(CACHE_KEY, JSON.stringify(next));
    return next;
  } catch {
    return fallback;
  } finally {
    clearTimeout(timer);
  }
}

// src/telemetry/index.ts
import crashlytics from "@react-native-firebase/crashlytics";
import analytics from "@react-native-firebase/analytics";
import { loadGaBaseline } from "./gaBaseline";
import { parseOsMajor, resolveOsTrack, type OsTrack } from "./osTrack";
 
let currentTrack: OsTrack = "unknown";
 
export function getOsTrack(): OsTrack {
  return currentTrack;
}
 
export async function initTelemetry(): Promise<void> {
  // 解決前のイベントも捨てません。unknown のまま先に送り始めます。
  await analytics().setUserProperty("os_track", currentTrack);
 
  const baseline = await loadGaBaseline();
  currentTrack = resolveOsTrack(baseline);
 
  const staleDays =
    (Date.now() - new Date(baseline.updatedAt).getTime()) / 86_400_000;
 
  await crashlytics().setAttributes({
    os_track: currentTrack,
    os_major: String(parseOsMajor() ?? "unknown"),
    ga_baseline: `${baseline.ios}/${baseline.android}`,
    baseline_stale_days: String(Math.floor(staleDays)),
  });
 
  await analytics().setUserProperty("os_track", currentTrack);
}

// scripts/releaseGate.ts
export type TrackStats = {
  track: "ga" | "prerelease" | "unknown";
  sessions: number;
  crashFreeRate: number; // 0.0 〜 1.0
};
 
export type GateResult = {
  pass: boolean;
  blockers: string[];
  warnings: string[];
};
 
const GA_MIN_SESSIONS = 500;
const GA_MIN_CRASH_FREE = 0.995;
const PRE_MIN_SESSIONS = 50;
const PRE_MIN_CRASH_FREE = 0.98;
const UNKNOWN_MAX_SHARE = 0.05;
 
const pct = (v: number) => `${(v * 100).toFixed(2)}%`;
 
export function evaluateGate(stats: TrackStats[]): GateResult {
  const blockers: string[] = [];
  const warnings: string[] = [];
 
  const byTrack = (t: TrackStats["track"]) => stats.find((s) => s.track === t);
  const total = stats.reduce((sum, s) => sum + s.sessions, 0);
 
  const ga = byTrack("ga");
  if (!ga || ga.sessions < GA_MIN_SESSIONS) {
    blockers.push(
      `GA トラックのセッションが ${ga?.sessions ?? 0} 件で、判断材料が足りません（${GA_MIN_SESSIONS} 件以上が必要）`
    );
  } else if (ga.crashFreeRate < GA_MIN_CRASH_FREE) {
    blockers.push(
      `GA クラッシュフリー率 ${pct(ga.crashFreeRate)} が閾値 ${pct(GA_MIN_CRASH_FREE)} を下回っています`
    );
  }
 
  // プレリリースは公開を止める条件にしませんが、是正キューには必ず積みます
  const pre = byTrack("prerelease");
  if (pre && pre.sessions >= PRE_MIN_SESSIONS && pre.crashFreeRate < PRE_MIN_CRASH_FREE) {
    warnings.push(
      `prerelease クラッシュフリー率 ${pct(pre.crashFreeRate)} — 正式リリース前に是正対象へ`
    );
  }
 
  const unknown = byTrack("unknown");
  if (unknown && total > 0 && unknown.sessions / total > UNKNOWN_MAX_SHARE) {
    warnings.push(
      `unknown が全体の ${pct(unknown.sessions / total)} を占めています — 基準値の配信を確認してください`
    );
  }
 
  return { pass: blockers.length === 0, blockers, warnings };
}

// src/telemetry/gaBaseline.ts（検証部分の差し替え）
export type BaselineLoad = {
  baseline: GaBaseline;
  rejected: "巻き戻し" | "飛躍" | "形式不正" | null;
};
 
function isValid(v: unknown): v is GaBaseline {
  const b = v as Partial<GaBaseline> | null;
  if (!b || typeof b.ios !== "number" || typeof b.android !== "number") return false;
  if (b.ios <= 0 || b.android <= 0) return false;
  // updatedAt を検証に含めます。ここを見ていないと staleDays が NaN になります
  if (typeof b.updatedAt !== "string") return false;
  return Number.isFinite(Date.parse(b.updatedAt));
}
 
function accept(next: GaBaseline, prev: GaBaseline): BaselineLoad["rejected"] {
  if (next.ios < prev.ios || next.android < prev.android) return "巻き戻し";
  // 正式リリースの前進は 1 メジャーずつです。2 以上は配信側の事故と見なします
  if (next.ios > prev.ios + 1 || next.android > prev.android + 1) return "飛躍";
  return null;
}
 
export function reconcile(remote: unknown, prev: GaBaseline): BaselineLoad {
  if (!isValid(remote)) return { baseline: prev, rejected: "形式不正" };
  const rejected = accept(remote, prev);
  return rejected ? { baseline: prev, rejected } : { baseline: remote, rejected: null };
}
 
export function staleDays(baseline: GaBaseline): number | null {
  const t = Date.parse(baseline.updatedAt);
  return Number.isFinite(t) ? Math.floor((Date.now() - t) / 86_400_000) : null;
}

// scripts/releaseGate.ts（追加分）
const GA_MIN_SHARE = 0.5;
 
export type GateContext = {
  baselineRejected: string | null;
  betaWindowOpen: boolean; // 次のメジャーのベータが配布されている期間か
};
 
export function evaluateTrackSanity(stats: TrackStats[], ctx: GateContext): string[] {
  const warnings: string[] = [];
  const total = stats.reduce((sum, s) => sum + s.sessions, 0);
  const ga = stats.find((s) => s.track === "ga");
  const pre = stats.find((s) => s.track === "prerelease");
 
  if (ctx.baselineRejected) {
    warnings.push(`基準値の配信を却下しました（${ctx.baselineRejected}）— 前回値で判定しています`);
  }
  if (total > 0 && ga && ga.sessions / total < GA_MIN_SHARE) {
    warnings.push(`GA トラックが全体の ${pct(ga.sessions / total)} しかありません — 基準値が進みすぎた疑い`);
  }
  if (ctx.betaWindowOpen && (!pre || pre.sessions === 0)) {
    warnings.push("ベータ期間中に prerelease が 0 件です — 分離が効いていない疑い");
  }
  return warnings;
}