fix(bot): fall back when analytics doubles are unavailable

Author: RavelloH

src/lib/edge/__tests__/admin-bot-analytics.test.ts

@@ -329,4 +329,100 @@ describe("admin bot analytics handlers", () => {
       pointCount: 1,
     });
   });
+
+  it("falls back to blob-only Analytics Engine queries when double columns are unavailable", async () => {
+    vi.spyOn(Date, "now").mockReturnValue(1_800_000_000_000);
+    const encrypted = await import("@/lib/edge/secret-encryption").then(
+      ({ encryptBotAnalyticsSecret }) =>
+        encryptBotAnalyticsSecret(
+          { MAIN_SECRET: "main-secret" },
+          "cf_reader_token",
+        ),
+    );
+    const configSelect = statement({
+      first: row({
+        apiTokenEncrypted: encrypted,
+        apiTokenHint: "••••oken",
+        configured: true,
+      }),
+    });
+    const siteSelect = statement({
+      all: [{ id: "site-1", name: "Blog", domain: "example.test" }],
+    });
+    const env = createEnv([configSelect, siteSelect]);
+    const fallbackBody = [
+      JSON.stringify({
+        timestamp: "2026-07-03 10:00:00",
+        siteId: "site-1",
+        kind: "pageview",
+        confidence: "medium",
+        reasons: "hosting_asn",
+        ip: "203.0.113.8",
+        userAgent: "Mozilla/5.0",
+        origin: "https://example.test",
+        hostname: "example.test",
+        pathname: "/post",
+        country: "JP",
+        region: "Tokyo",
+        city: "Tokyo",
+        continent: "AS",
+        colo: "NRT",
+        asnText: "16509",
+        asOrganization: "Amazon.com, Inc.",
+        verifiedBotCategory: "",
+        rayId: "ray-1",
+        traceId: "trace-1",
+        metadataJson: "{}",
+      }),
+      "",
+    ].join("\n");
+    const fetchMock = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            errors: [
+              {
+                message:
+                  'Input was invalid: unable to find type of column: "double1"',
+              },
+            ],
+          }),
+          { status: 422 },
+        ),
+      )
+      .mockResolvedValueOnce(new Response(fallbackBody, { status: 200 }));
+
+    const response = await handleBotAnalyticsAdmin(
+      request("/api/private/admin/bot-analytics?minutes=60&limit=10"),
+      env,
+      new URL(
+        "https://app.test/api/private/admin/bot-analytics?minutes=60&limit=10",
+      ),
+    );
+    const body = await jsonOf(response);
+
+    expect(response.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const firstSql = String(
+      (fetchMock.mock.calls[0]?.[1] as RequestInit | undefined)?.body || "",
+    );
+    const fallbackSql = String(
+      (fetchMock.mock.calls[1]?.[1] as RequestInit | undefined)?.body || "",
+    );
+    expect(firstSql).toContain("double1 AS receivedAt");
+    expect(fallbackSql).not.toContain("double1");
+    expect(fallbackSql).toContain("ORDER BY timestamp DESC");
+    expect(body.events[0]).toMatchObject({
+      siteName: "Blog",
+      asn: 16509,
+      receivedAt: Date.UTC(2026, 6, 3, 10, 0, 0),
+    });
+    expect(body.summary).toMatchObject({
+      total: 1,
+      mediumConfidence: 1,
+      uniqueAsns: 1,
+      uniqueCountries: 1,
+    });
+  });
 });

src/lib/edge/admin-bot-analytics.ts

@@ -92,9 +92,24 @@ function buildBotAnalyticsSql(input: {
   dataset: string;
   since: number;
   limit: number;
+  includeDoubles?: boolean;
 }) {
   const dataset = analyticsDatasetIdentifier(input.dataset);
   const sinceSeconds = Math.floor(input.since / 1000);
+  const doubleSelect = input.includeDoubles
+    ? `,
+      double1 AS receivedAt,
+      double2 AS asn,
+      double3 AS latitude,
+      double4 AS longitude,
+      double5 AS botScore,
+      double6 AS userAgentLength`
+    : "";
+  const doubleFilter = input.includeDoubles
+    ? `
+      AND double1 >= ${input.since}`
+    : "";
+  const orderBy = input.includeDoubles ? "double1" : "timestamp";
   return `
     SELECT
       timestamp,
@@ -117,17 +132,10 @@ function buildBotAnalyticsSql(input: {
       blob17 AS verifiedBotCategory,
       blob18 AS rayId,
       blob19 AS traceId,
-      blob20 AS metadataJson,
-      double1 AS receivedAt,
-      double2 AS asn,
-      double3 AS latitude,
-      double4 AS longitude,
-      double5 AS botScore,
-      double6 AS userAgentLength
+      blob20 AS metadataJson${doubleSelect}
     FROM ${dataset}
-    WHERE timestamp >= toDateTime(${sinceSeconds})
-      AND double1 >= ${input.since}
-    ORDER BY double1 DESC
+    WHERE timestamp >= toDateTime(${sinceSeconds})${doubleFilter}
+    ORDER BY ${orderBy} DESC
     LIMIT ${input.limit}
     FORMAT JSONEachRow
   `;
@@ -184,6 +192,16 @@ function parseJsonEachRow(text: string): Record<string, unknown>[] {
     .map((line) => JSON.parse(line) as Record<string, unknown>);
 }
 
+function parseAnalyticsTimestampMs(value: unknown): number {
+  const text = String(value || "").trim();
+  if (!text) return 0;
+  const normalized = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/.test(text)
+    ? `${text.replace(" ", "T")}Z`
+    : text;
+  const parsed = Date.parse(normalized);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
 function normalizeBotRow(
   row: Record<string, unknown>,
   sites: Map<string, { name: string; domain: string }>,
@@ -195,9 +213,11 @@ function normalizeBotRow(
     .map((reason) => reason.trim())
     .filter(Boolean);
   const botScore = toFiniteNumber(row.botScore, 0);
+  const receivedAt =
+    toFiniteNumber(row.receivedAt) || parseAnalyticsTimestampMs(row.timestamp);
   return {
     timestamp: clampString(String(row.timestamp || ""), 64),
-    receivedAt: toFiniteNumber(row.receivedAt),
+    receivedAt,
     siteId,
     siteName: clampString(site?.name || siteId || "Unknown site", 160),
     siteDomain: clampString(site?.domain || "", 255),
@@ -226,6 +246,17 @@ function normalizeBotRow(
   };
 }
 
+function shouldRetryBotAnalyticsWithoutDoubles(result: {
+  status: number;
+  body: string;
+}): boolean {
+  if (result.status !== 422) return false;
+  const body = result.body.toLowerCase();
+  return (
+    body.includes("unable to find type of column") && /double\d+/.test(body)
+  );
+}
+
 function bucketSizeMs(minutes: number): number {
   if (minutes <= 60) return 5 * 60 * 1000;
   if (minutes <= 360) return 30 * 60 * 1000;
@@ -512,12 +543,25 @@ export async function handleBotAnalyticsAdmin(
     dataset: config.dataset,
     since: from,
     limit,
+    includeDoubles: true,
   });
-  const result = await queryCloudflareAnalyticsEngine({
+  let result = await queryCloudflareAnalyticsEngine({
     accountId: config.accountId,
     token,
     sql,
   });
+  if (!result.ok && shouldRetryBotAnalyticsWithoutDoubles(result)) {
+    result = await queryCloudflareAnalyticsEngine({
+      accountId: config.accountId,
+      token,
+      sql: buildBotAnalyticsSql({
+        dataset: config.dataset,
+        since: from,
+        limit,
+        includeDoubles: false,
+      }),
+    });
+  }
   if (!result.ok) {
     return bad(
       cloudflareAnalyticsErrorMessage(result),