target-supabase-sdk 0.2.0 → 0.2.1

package/src/shared/log/create-logger.ts

@@ -0,0 +1,51 @@
+import { type LoggerWithScope, type LogLevel, logManager } from "./log-manager";
+import { createScope, type LogScope, type LogScopePatch } from "./log-scope";
+
+type CreateLoggerLevelOption = {
+    /** Overrides global minimum level for this logger only. */
+    minLevel?: LogLevel;
+};
+
+/** Build scope from fields, then bind a logger. */
+export type CreateLoggerFromModuleInput = {
+    module: string;
+    traceId?: string;
+    traceParentId?: string | null;
+    labels?: Record<string, string>;
+} & CreateLoggerLevelOption;
+
+/** Bind a logger to an existing {@link LogScope}. */
+export type CreateLoggerFromScopeInput = {
+    scope: LogScope;
+} & CreateLoggerLevelOption;
+
+export type CreateLoggerInput = CreateLoggerFromModuleInput | CreateLoggerFromScopeInput;
+
+function isScopeInput(input: CreateLoggerInput): input is CreateLoggerFromScopeInput {
+    return "scope" in input;
+}
+
+/**
+ * Returns a scoped logger — one entry for all call sites.
+ *
+ * - `{ module, traceId?, labels?, … }` — creates a scope (API handlers, one-shot calls)
+ * - `{ scope, minLevel? }` — binds an existing scope (`createScope`, `patchScope`, …)
+ */
+export function createLogger(input: CreateLoggerInput): LoggerWithScope {
+    const { minLevel } = input;
+    const scopeOptions = minLevel != null ? { minLevel } : undefined;
+
+    if (isScopeInput(input)) {
+        return logManager.withScope(input.scope, scopeOptions).logger;
+    }
+
+    const scope = createScope({
+        module: input.module,
+        traceId: input.traceId?.trim() || logManager.generateTraceId(),
+        traceParentId: input.traceParentId,
+        labels: input.labels,
+    });
+    return logManager.withScope(scope, scopeOptions).logger;
+}
+
+export type { LogScopePatch };

package/src/shared/log/enable-log-persist.ts

@@ -0,0 +1,225 @@
+import { resolve } from "node:path";
+import { envBool } from "../../node/env/env-parsers";
+import { readEnv, requireEnv } from "../../node/env/require-env";
+import { pollUntil } from "../../node/readiness";
+import { createLogger } from "./create-logger";
+import { LogPersist } from "./log-persist";
+import {
+    logPersistConfigFromEnv,
+    logPersistEnabledFromEnv,
+    logPersistProcessFromEnv,
+    logPersistRegistryDirFromEnv,
+    logPersistServiceFromEnv,
+    resolveLogPersistConfig,
+} from "./log-persist.config";
+import type {
+    EnableLogPersistOptions,
+    EnsureLogPersistFromEnvOptions,
+    LogPersistReadySnapshot,
+    LogPersistStats,
+    WaitForLogPersistReadyOptions,
+} from "./log-persist.interface";
+import { registerLogPersistOffer } from "./log-persist-hook";
+import { LOG_PERSIST_TOPIC, persistLogger } from "./log-persist-logger";
+import { defaultLogPersistRegistryPath, readLogPersistRegistry } from "./log-persist-registry";
+
+export { logPersistEnabledFromEnv };
+
+function resolveRegistryFilePath(explicit?: string): string {
+    if (explicit != null && explicit.trim() !== "") {
+        return resolve(explicit);
+    }
+    const dir = logPersistRegistryDirFromEnv();
+    if (dir == null) {
+        throw new Error(
+            "[LogPersist] registry path required: set registryFilePath option or LOG_PERSIST_REGISTRY_DIR / RUNTIME_DATA_DIR",
+        );
+    }
+    return defaultLogPersistRegistryPath(resolve(dir));
+}
+
+export async function enableLogPersist(options: EnableLogPersistOptions): Promise<void> {
+    const registryFilePath = options.registryFilePath != null ? resolve(options.registryFilePath) : undefined;
+    const resolvedRegistry = registryFilePath ?? resolveRegistryFilePath();
+
+    const envConfig = logPersistConfigFromEnv();
+    await LogPersist.getInstance().enable({
+        ...options,
+        registryFilePath: resolvedRegistry,
+        config: resolveLogPersistConfig({
+            fast: { ...envConfig.fast, ...options.config?.fast },
+            medium: { ...envConfig.medium, ...options.config?.medium },
+            slow: { ...envConfig.slow, ...options.config?.slow },
+            postTimeoutMs: options.config?.postTimeoutMs ?? envConfig.postTimeoutMs,
+            shutdownDrainTimeoutMs: options.config?.shutdownDrainTimeoutMs ?? envConfig.shutdownDrainTimeoutMs,
+        }),
+    });
+}
+
+export async function disableLogPersist(): Promise<void> {
+    await LogPersist.getInstance().disable();
+}
+
+export function getLogPersistStats(): LogPersistStats {
+    return LogPersist.getInstance().getStats();
+}
+
+/**
+ * Enable log persistence when LOG_PERSIST_ENABLED=true.
+ * `process` / `service` can be passed explicitly or via LOG_PERSIST_PROCESS / LOG_PERSIST_SERVICE.
+ */
+export async function ensureLogPersistFromEnv(options: EnsureLogPersistFromEnvOptions = {}): Promise<boolean> {
+    if (!logPersistEnabledFromEnv()) {
+        registerLogPersistOffer(null);
+        return false;
+    }
+
+    const service = options.service ?? logPersistServiceFromEnv();
+    const processName = options.process ?? logPersistProcessFromEnv();
+    if (service == null || service === "") {
+        throw new Error("[LogPersist] LOG_PERSIST_SERVICE is required when LOG_PERSIST_ENABLED=true");
+    }
+    if (processName == null || processName === "") {
+        throw new Error(
+            "[LogPersist] LOG_PERSIST_PROCESS is required when LOG_PERSIST_ENABLED=true (or pass process option)",
+        );
+    }
+
+    const registryFilePath =
+        options.registryFilePath != null ? resolve(options.registryFilePath) : resolveRegistryFilePath();
+
+    await enableLogPersist({
+        service,
+        process: processName,
+        registryFilePath,
+        config: options.config,
+    });
+
+    const lifecycleLogger = createLogger({ module: "log-persist" });
+    lifecycleLogger.info("log persist enabled from env", {
+        topic: LOG_PERSIST_TOPIC,
+        data: { service, process: processName, registryFilePath },
+    });
+
+    return true;
+}
+
+/**
+ * Preload guard: when persistence is enabled, required env must be present before app code runs.
+ */
+export function validateLogPersistPreloadEnv(env: NodeJS.ProcessEnv = process.env): void {
+    if (!envBool("LOG_PERSIST_ENABLED", false, env)) {
+        return;
+    }
+
+    const missing: string[] = [];
+    if (readEnv("LOG_PERSIST_SERVICE", env) == null) {
+        missing.push("LOG_PERSIST_SERVICE");
+    }
+    const registryDir = logPersistRegistryDirFromEnv(env);
+    if (registryDir == null) {
+        missing.push("LOG_PERSIST_REGISTRY_DIR or RUNTIME_DATA_DIR");
+    }
+
+    if (missing.length > 0) {
+        throw new Error(`[LogPersist] preload env incomplete: ${missing.join(", ")}`);
+    }
+}
+
+function evaluateLogPersistReady(
+    state: Awaited<ReturnType<typeof readLogPersistRegistry>>,
+    expectedProcesses: string[],
+    staleMs: number,
+    now: number,
+): LogPersistReadySnapshot {
+    const missing: string[] = [];
+    const stale: string[] = [];
+    const registered: string[] = [];
+
+    for (const processName of expectedProcesses) {
+        const record = state.processes[processName];
+        if (record == null) {
+            missing.push(processName);
+            continue;
+        }
+
+        const heartbeatAt = Date.parse(record.lastHeartbeatAt);
+        if (!Number.isFinite(heartbeatAt) || now - heartbeatAt > staleMs) {
+            stale.push(processName);
+            continue;
+        }
+
+        registered.push(processName);
+    }
+
+    return {
+        ok: missing.length === 0 && stale.length === 0,
+        missing,
+        stale,
+        registered,
+    };
+}
+
+/**
+ * Wait until every expected process has registered in the shared registry with a fresh heartbeat.
+ * Call from the service main process after spawning children.
+ */
+export async function waitForLogPersistReady(options: WaitForLogPersistReadyOptions): Promise<LogPersistReadySnapshot> {
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 500;
+    const staleMs = options.staleMs ?? 90_000;
+
+    let last: LogPersistReadySnapshot = {
+        ok: false,
+        missing: [...options.expectedProcesses],
+        stale: [],
+        registered: [],
+    };
+
+    try {
+        await pollUntil({
+            intervalMs: pollIntervalMs,
+            timeoutMs,
+            until: async () => {
+                const state = await readLogPersistRegistry(options.registryFilePath);
+                if (state.service !== options.service) {
+                    last = {
+                        ok: false,
+                        missing: options.expectedProcesses,
+                        stale: [],
+                        registered: [],
+                    };
+                    return false;
+                }
+                last = evaluateLogPersistReady(state, options.expectedProcesses, staleMs, Date.now());
+                return last.ok;
+            },
+        });
+    } catch {
+        persistLogger.warn("waitForLogPersistReady timed out", {
+            timeoutMs,
+            expectedProcesses: options.expectedProcesses,
+            ...last,
+        });
+    }
+
+    return last;
+}
+
+export async function snapshotLogPersistReady(options: {
+    registryFilePath: string;
+    service: string;
+    expectedProcesses: string[];
+    staleMs?: number;
+}): Promise<LogPersistReadySnapshot> {
+    const state = await readLogPersistRegistry(options.registryFilePath);
+    return evaluateLogPersistReady(state, options.expectedProcesses, options.staleMs ?? 90_000, Date.now());
+}
+
+export function resolveLogPersistRegistryPath(registryDir?: string): string {
+    const dir = registryDir ?? logPersistRegistryDirFromEnv();
+    if (dir == null) {
+        requireEnv("LOG_PERSIST_REGISTRY_DIR");
+    }
+    return defaultLogPersistRegistryPath(resolve(dir ?? ""));
+}

package/src/shared/log/index.ts

@@ -2,22 +2,30 @@
  * Log domain public API — curated re-exports only.
  */
 
+export type {
+    CreateLoggerFromModuleInput,
+    CreateLoggerFromScopeInput,
+    CreateLoggerInput,
+} from "./create-logger";
+// create-logger
+export { createLogger } from "./create-logger";
+export type { LogEntry, LoggerWithScope, LogOptions, LogRestParams, WithScopeOptions } from "./log-manager";
 // log-manager
-export { logManager, LogManager, LogLevel } from "./log-manager";
-export type { LogEntry, LogOptions, LoggerWithScope, LogRestParams } from "./log-manager";
-
-// create-api-logger
-export { createApiLogger } from "./create-api-logger";
-export type { CreateApiLoggerOptions } from "./create-api-logger";
-
+export { LogLevel, LogManager, logManager } from "./log-manager";
+export type {
+    CreateScopeInput,
+    LoggerResetScopePatch,
+    LogScope,
+    LogScopeInput,
+    LogScopePatch,
+    PatchScopeInput,
+} from "./log-scope";
 // log-scope
 export {
-    applyScopePatch,
-    createChildScope,
-    createRootScope,
+    createScope,
     formatScopeLabels,
     normalizeScope,
+    patchScope,
     resolveLogData,
     withModule,
 } from "./log-scope";
-export type { LogScope, LogScopeInput, LogScopePatch, CreateRootScopeInput, CreateChildScopeInput } from "./log-scope";

package/src/shared/log/log-manager.ts

@@ -1,12 +1,7 @@
 import { isDevEnvironment } from "../../core.utils";
 import { generateUniqueId } from "../utils/id.utils";
-import {
-    applyScopePatch,
-    formatScopeLabels,
-    resolveLogData,
-    type LogScope,
-    type LogScopePatch,
-} from "./log-scope";
+import { offerToLogPersist } from "./log-persist-hook";
+import { formatScopeLabels, type LoggerResetScopePatch, type LogScope, patchScope, resolveLogData } from "./log-scope";
 
 /**
  * Log severity and semantics (low → high). `minLevel` filters by {@link LOG_LEVEL_RANK}.
@@ -42,14 +37,14 @@ interface LogEntry extends LogScope {
     timestamp: number;
     level: LogLevel;
     message: string;
-    topic: string | null;
+    topic: string;
     extra?: string;
     /** Per-line structured business payload. */
     data?: unknown;
 }
 
 type LogRestParams = {
-    topic?: LogEntry["topic"];
+    topic: string;
     extra?: LogEntry["extra"];
     data?: unknown;
 };
@@ -58,43 +53,43 @@ type LogParams = { message: LogEntry["message"] } & LogRestParams;
 
 interface LogEntryPayload extends LogScope {
     message: LogEntry["message"];
-    topic?: LogEntry["topic"];
+    topic: LogEntry["topic"];
     extra?: LogEntry["extra"];
     data?: LogEntry["data"];
     level: LogEntry["level"];
 }
 
 interface LogOptions {
-    defaultTopic: LogEntry["topic"];
     formatTimestamp: boolean;
     formatEmoji: boolean;
     formatPrefix: string;
-    maxHistoryLength: number;
     /** Logs below this level are skipped. Defaults to DEBUG in dev, INFO in production. */
     minLevel?: LogLevel;
     onLog?: (entry: LogEntry) => void;
 }
 
+/** Per-scoped-logger options for {@link LogManager.withScope}. */
+interface WithScopeOptions {
+    /** Overrides global {@link LogOptions.minLevel} for this logger instance. */
+    minLevel?: LogLevel;
+}
+
 const DEFAULT_OPTIONS: LogOptions = {
-    defaultTopic: null,
     formatTimestamp: true,
     formatEmoji: true,
     formatPrefix: "",
-    maxHistoryLength: 4096,
     minLevel: isDevEnvironment() ? LogLevel.DEBUG : LogLevel.INFO,
 };
 
 interface LoggerWithScope {
-    debug: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    info: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    success: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    warn: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    error: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    critical: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Merge partial fields into this logger's bound scope. */
-    resetScope: (fields: LogScopePatch) => void;
-    /** @deprecated use {@link LoggerWithScope.resetScope} */
-    resetContext: (fields: LogScopePatch) => void;
+    debug: (message: LogParams["message"], restParams: LogRestParams) => void;
+    info: (message: LogParams["message"], restParams: LogRestParams) => void;
+    success: (message: LogParams["message"], restParams: LogRestParams) => void;
+    warn: (message: LogParams["message"], restParams: LogRestParams) => void;
+    error: (message: LogParams["message"], restParams: LogRestParams) => void;
+    critical: (message: LogParams["message"], restParams: LogRestParams) => void;
+    /** Merge labels / module into this logger's bound scope (trace fields are not mutable). */
+    resetScope: (patch: LoggerResetScopePatch) => void;
 }
 
 function mergeLogOptions(options?: Partial<LogOptions>): LogOptions {
@@ -134,7 +129,6 @@ function validateLogScope(logScope: LogScope): void {
 class LogManager {
     private static instance: LogManager;
     private options: LogOptions;
-    private history: LogEntry[] = [];
     private readonly levelEmojis = {
         [LogLevel.DEBUG]: "🔍",
         [LogLevel.INFO]: "ℹ️",
@@ -152,7 +146,9 @@ class LogManager {
         if (!LogManager.instance) {
             LogManager.instance = new LogManager(options);
         } else if (options != null && Object.keys(options).length > 0) {
-            console.warn("[LogManager] getInstance(options) ignored — singleton already created. Use setOptions() instead.");
+            console.warn(
+                "[LogManager] getInstance(options) ignored — singleton already created. Use setOptions() instead.",
+            );
         }
         return LogManager.instance;
     }
@@ -161,20 +157,13 @@ class LogManager {
         this.options = mergeLogOptions({ ...this.options, ...options });
     }
 
-    public getHistory(): LogEntry[] {
-        return [...this.history];
-    }
-
-    public clearHistory(): void {
-        this.history = [];
-    }
-
     private getMinLevel(): LogLevel {
         return this.options.minLevel ?? DEFAULT_OPTIONS.minLevel ?? LogLevel.INFO;
     }
 
-    private shouldLog(level: LogLevel): boolean {
-        return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[this.getMinLevel()];
+    private shouldLog(level: LogLevel, scopeMinLevel?: LogLevel): boolean {
+        const minLevel = scopeMinLevel ?? this.getMinLevel();
+        return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[minLevel];
     }
 
     private createLogEntry(payload: LogEntryPayload): LogEntry {
@@ -183,7 +172,7 @@ class LogManager {
             timestamp: Date.now(),
             level,
             message,
-            topic: topic === undefined ? this.options.defaultTopic : topic,
+            topic,
             module,
             traceId,
             traceParentId,
@@ -210,15 +199,14 @@ class LogManager {
 
         parts.push(this.formatLevelTag(entry));
         parts.push(
-            `traceId=${entry.traceId} parent=${entry.traceParentId ?? "null"} labels=${formatScopeLabels(entry.labels)} module=${entry.module} topic=${entry.topic ?? "--"}`
+            `traceId=${entry.traceId} parent=${entry.traceParentId ?? "null"} labels=${formatScopeLabels(entry.labels)} module=${entry.module} topic=${entry.topic}`,
         );
 
         if (this.options.formatPrefix) {
             parts.push(`prefix=${this.options.formatPrefix}`);
         }
 
-        const message =
-            entry.level === LogLevel.CRITICAL ? `>>> ${entry.message} <<<` : entry.message;
+        const message = entry.level === LogLevel.CRITICAL ? `>>> ${entry.message} <<<` : entry.message;
         parts.push(`| ${message}`);
 
         if (entry.extra) {
@@ -247,14 +235,23 @@ class LogManager {
         }
     }
 
-    private log(level: LogLevel, message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
-        if (!this.shouldLog(level)) {
+    private log(
+        level: LogLevel,
+        message: LogParams["message"],
+        logScope: LogScope,
+        restParams: LogRestParams,
+        scopeMinLevel?: LogLevel,
+    ) {
+        if (!this.shouldLog(level, scopeMinLevel)) {
             return;
         }
 
         validateLogScope(logScope);
+        if (!restParams.topic?.trim()) {
+            throw new Error("[LogManager] topic is required on every log call");
+        }
 
-        const { topic, extra } = restParams ?? {};
+        const { topic, extra } = restParams;
         const data = resolveLogData(restParams);
         const entry = this.createLogEntry({
             level,
@@ -265,71 +262,70 @@ class LogManager {
             ...logScope,
         });
 
-        this.history.push(entry);
-        if (this.history.length > this.options.maxHistoryLength) {
-            this.history.shift();
-        }
-
         const formatted = this.formatLog(entry);
         this.emitLog(entry, formatted);
         this.options.onLog?.(entry);
+        offerToLogPersist(entry);
     }
 
     public generateTraceId(): string {
         return generateUniqueId();
     }
 
-    public debug(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public debug(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.DEBUG, message, logScope, restParams);
     }
 
-    public info(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public info(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.INFO, message, logScope, restParams);
     }
 
-    public success(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public success(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.SUCCESS, message, logScope, restParams);
     }
 
-    public warn(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public warn(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.WARN, message, logScope, restParams);
     }
 
-    public error(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public error(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.ERROR, message, logScope, restParams);
     }
 
-    public critical(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+    public critical(message: LogParams["message"], logScope: LogScope, restParams: LogRestParams) {
         this.log(LogLevel.CRITICAL, message, logScope, restParams);
     }
 
-    public withScope(scope: LogScope): { logger: LoggerWithScope; scope: LogScope } {
+    public withScope(scope: LogScope, options?: WithScopeOptions): { logger: LoggerWithScope; scope: LogScope } {
         const boundScope: LogScope = { ...scope, labels: scope.labels ? { ...scope.labels } : undefined };
+        const scopeMinLevel = options?.minLevel;
 
         const logger: LoggerWithScope = {
-            debug: (message, restParams) => this.debug(message, boundScope, restParams),
-            info: (message, restParams) => this.info(message, boundScope, restParams),
-            success: (message, restParams) => this.success(message, boundScope, restParams),
-            warn: (message, restParams) => this.warn(message, boundScope, restParams),
-            error: (message, restParams) => this.error(message, boundScope, restParams),
-            critical: (message, restParams) => this.critical(message, boundScope, restParams),
-            resetScope: (fields) => {
-                const next = applyScopePatch(boundScope, fields);
+            debug: (message, restParams) => this.log(LogLevel.DEBUG, message, boundScope, restParams, scopeMinLevel),
+            info: (message, restParams) => this.log(LogLevel.INFO, message, boundScope, restParams, scopeMinLevel),
+            success: (message, restParams) =>
+                this.log(LogLevel.SUCCESS, message, boundScope, restParams, scopeMinLevel),
+            warn: (message, restParams) => this.log(LogLevel.WARN, message, boundScope, restParams, scopeMinLevel),
+            error: (message, restParams) => this.log(LogLevel.ERROR, message, boundScope, restParams, scopeMinLevel),
+            critical: (message, restParams) =>
+                this.log(LogLevel.CRITICAL, message, boundScope, restParams, scopeMinLevel),
+            resetScope: (patch) => {
+                const next = patchScope({
+                    scope: boundScope,
+                    patch,
+                    allowTraceMutation: false,
+                });
                 boundScope.module = next.module;
                 boundScope.traceId = next.traceId;
                 boundScope.traceParentId = next.traceParentId;
                 boundScope.labels = next.labels;
             },
-            resetContext: (fields) => {
-                logger.resetScope(fields);
-            },
         };
 
         return { logger, scope: boundScope };
     }
-
 }
 
 export const logManager = LogManager.getInstance();
-export { LogManager, LogLevel };
-export type { LogOptions, LogEntry, LoggerWithScope, LogRestParams };
+export type { LogEntry, LoggerWithScope, LogOptions, LogRestParams, WithScopeOptions };
+export { LogLevel, LogManager };

package/src/shared/log/log-persist-batch-id.ts

@@ -0,0 +1,43 @@
+import { createHash } from "node:crypto";
+import type { LogEntry } from "./log-manager";
+import type { LogPersistLane } from "./log-persist.interface";
+
+const BATCH_ID_VERSION = 1;
+
+/** Stable subset of LogEntry for idempotency hashing (same batch → same key). */
+function canonicalLogEntry(entry: LogEntry): Record<string, unknown> {
+    return {
+        timestamp: entry.timestamp,
+        level: entry.level,
+        message: entry.message,
+        topic: entry.topic,
+        module: entry.module,
+        traceId: entry.traceId,
+        traceParentId: entry.traceParentId ?? null,
+        extra: entry.extra ?? null,
+        data: entry.data ?? null,
+        labels: entry.labels ?? null,
+    };
+}
+
+/**
+ * Deterministic List.value for a log batch — retries after timeout map to the same row key.
+ * SHA-256 over canonical JSON (service + process + lane + entries in order).
+ */
+export function computeLogBatchIdempotencyKey(input: {
+    service: string;
+    process: string;
+    lane: LogPersistLane;
+    entries: LogEntry[];
+}): string {
+    const payload = {
+        v: BATCH_ID_VERSION,
+        service: input.service,
+        process: input.process,
+        lane: input.lane,
+        entries: input.entries.map(canonicalLogEntry),
+    };
+
+    const hash = createHash("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+    return `${hash.slice(0, 32)}`;
+}