deepline 0.1.222 → 0.1.224

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -15,6 +15,13 @@ import {
   WorkflowEntrypoint,
   exports as workersExports,
 } from 'cloudflare:workers';
+import {
+  createWorkerTelemetry,
+  type TelemetryEvent,
+  type TelemetryFields,
+  type TelemetryScalar,
+} from '../../../shared_libs/observability/worker-telemetry';
+import { createSecretRedactionContext } from '../../../shared_libs/play-runtime/secret-redaction';
 import {
   _dispatcherBindingImpl as createDispatcherWorkflowBinding,
   dispatchWorkflow,
@@ -83,6 +90,59 @@ import {
 
 export { DynamicWorkflowBinding };
 
+const coordinatorTelemetry = createWorkerTelemetry({
+  service: 'play-runtime',
+  component: 'coordinator',
+});
+const coordinatorStorageRedactor = createSecretRedactionContext();
+const coordinatorPerfTelemetry = createWorkerTelemetry({
+  service: 'play-runtime',
+  component: 'coordinator',
+  adapter: {
+    emit(event: TelemetryEvent) {
+      console.log(`[perf-trace] ${JSON.stringify(event)}`);
+    },
+  },
+});
+
+function coordinatorTelemetryFields(input: object): TelemetryFields {
+  const fields: Record<string, TelemetryScalar> = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (
+      value === undefined ||
+      value === null ||
+      typeof value === 'string' ||
+      typeof value === 'number' ||
+      typeof value === 'boolean'
+    ) {
+      fields[key] = value;
+    }
+  }
+  return fields;
+}
+
+function recordCoordinatorEvent(
+  level: 'info' | 'warn' | 'error',
+  event: string,
+  tag: string,
+  input: Record<string, unknown> = {},
+): void {
+  const telemetry = coordinatorTelemetry.child({
+    context: {
+      runId: typeof input.runId === 'string' ? input.runId : null,
+      orgId: typeof input.orgId === 'string' ? input.orgId : null,
+      playName: typeof input.playName === 'string' ? input.playName : null,
+      requestId: typeof input.requestId === 'string' ? input.requestId : null,
+    },
+  });
+  const fields = coordinatorTelemetryFields(input);
+  if (level === 'error') {
+    void telemetry.error(event, input.error ?? input.message, fields, { tag });
+  } else {
+    void telemetry[level](event, fields, { tag });
+  }
+}
+
 export type PlayWorkflowParams = {
   runId: string;
   playId: string;
@@ -389,7 +449,11 @@ function buildCoordinatorPerfTracePayload(
 }
 
 function logCoordinatorPerfTrace(payload: CoordinatorPerfTracePayload): void {
-  console.log(`[perf-trace] ${JSON.stringify(payload)}`);
+  void coordinatorPerfTelemetry
+    .child({ context: { runId: payload.runId } })
+    .info(payload.phase, coordinatorTelemetryFields(payload), {
+      tag: '[perf-trace]',
+    });
 }
 
 function recordCoordinatorPerfTrace(event: CoordinatorPerfTraceInput): void {
@@ -417,7 +481,7 @@ async function appendCoordinatorPerfTrace(
     {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(payload),
+      body: JSON.stringify(coordinatorStorageRedactor.redact(payload)),
     },
   );
   if (!response.ok) {
@@ -438,11 +502,16 @@ function recordCoordinatorPerfTraceBuffered(
   if (!payload) return;
   logCoordinatorPerfTrace(payload);
   const append = appendCoordinatorPerfTrace(env, payload).catch((error) => {
-    console.warn('[coordinator] failed to buffer perf trace', {
-      runId: payload.runId,
-      phase: payload.phase,
-      error: error instanceof Error ? error.message : String(error),
-    });
+    return coordinatorTelemetry
+      .child({ context: { runId: payload.runId } })
+      .warn(
+        'coordinator.perf_trace.buffer_failed',
+        {
+          phase: payload.phase,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        { tag: '[coordinator] failed to buffer perf trace' },
+      );
   });
   if (typeof ctx?.waitUntil === 'function') {
     ctx.waitUntil(append);
@@ -595,7 +664,7 @@ async function writeCoordinatorChildTerminalState(input: {
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({
         eventKey: input.eventKey,
-        data: input.data,
+        data: coordinatorStorageRedactor.redact(input.data),
         storedAt: Date.now(),
       }),
     },
@@ -858,12 +927,17 @@ async function callRunScopedControl<T>(
     } catch (error) {
       const handoffMessage = durableObjectDeployHandoffMessage(error);
       if (handoffMessage && attempt < maxAttempts) {
-        console.warn('[coordinator] run state DO deploy handoff retry', {
-          runId,
-          path,
-          attempt,
-          error: handoffMessage,
-        });
+        recordCoordinatorEvent(
+          'warn',
+          'coordinator.run_state.handoff_retry',
+          '[coordinator] run state DO deploy handoff retry',
+          {
+            runId,
+            path,
+            attempt,
+            error: handoffMessage,
+          },
+        );
         await sleepForDurableObjectDeployHandoffRetry(attempt - 1);
         continue;
       }
@@ -877,13 +951,18 @@ async function callRunScopedControl<T>(
     const responseText = (await response.text().catch(() => '')).slice(0, 400);
     const handoffMessage = durableObjectDeployHandoffMessage(responseText);
     if (handoffMessage && attempt < maxAttempts) {
-      console.warn('[coordinator] run state DO deploy handoff retry', {
-        runId,
-        path,
-        attempt,
-        status: response.status,
-        error: handoffMessage,
-      });
+      recordCoordinatorEvent(
+        'warn',
+        'coordinator.run_state.handoff_retry',
+        '[coordinator] run state DO deploy handoff retry',
+        {
+          runId,
+          path,
+          attempt,
+          status: response.status,
+          error: handoffMessage,
+        },
+      );
       await sleepForDurableObjectDeployHandoffRetry(attempt - 1);
       continue;
     }
@@ -1341,14 +1420,19 @@ async function markWorkflowRuntimeFailure(input: {
       const response = await fetch(url, { method: 'POST', headers, body });
       if (response.ok) {
         if (attempt > 0) {
-          console.info('[coordinator.runtime_api.retry]', {
-            action: 'append_run_events',
-            status: 'ok',
-            attempt,
-            runId,
-            requestId,
-            baseOrigin: safeOrigin(baseUrl),
-          });
+          recordCoordinatorEvent(
+            'info',
+            'coordinator.runtime_api.retry',
+            '[coordinator.runtime_api.retry]',
+            {
+              action: 'append_run_events',
+              status: 'ok',
+              attempt,
+              runId,
+              requestId,
+              baseOrigin: safeOrigin(baseUrl),
+            },
+          );
         }
         return;
       }
@@ -1367,26 +1451,37 @@ async function markWorkflowRuntimeFailure(input: {
       lastError = error;
     }
     if (attempt < backoffMs.length) {
-      console.warn('[coordinator.runtime_api.retry]', {
-        action: 'append_run_events',
-        status: 'retry',
-        attempt: attempt + 1,
-        retryDelayMs: backoffMs[attempt],
-        runId,
-        requestId,
-        baseOrigin: safeOrigin(baseUrl),
-        error:
-          lastError instanceof Error
-            ? lastError.message.slice(0, 300)
-            : String(lastError).slice(0, 300),
-      });
+      recordCoordinatorEvent(
+        'warn',
+        'coordinator.runtime_api.retry',
+        '[coordinator.runtime_api.retry]',
+        {
+          action: 'append_run_events',
+          status: 'retry',
+          attempt: attempt + 1,
+          retryDelayMs: backoffMs[attempt],
+          runId,
+          requestId,
+          baseOrigin: safeOrigin(baseUrl),
+          error:
+            lastError instanceof Error
+              ? lastError.message.slice(0, 300)
+              : String(lastError).slice(0, 300),
+        },
+      );
       await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt]));
     }
   }
-  console.error('[coordinator] failed to mark workflow runtime failure', {
-    runId,
-    message: lastError instanceof Error ? lastError.message : String(lastError),
-  });
+  recordCoordinatorEvent(
+    'error',
+    'coordinator.workflow_runtime_failure.mark_failed',
+    '[coordinator] failed to mark workflow runtime failure',
+    {
+      runId,
+      message:
+        lastError instanceof Error ? lastError.message : String(lastError),
+    },
+  );
 }
 
 async function appendWorkflowChildCompletedRunEvent(input: {
@@ -1767,10 +1862,15 @@ async function restartWorkflowAfterPlatformReset(input: {
     env: input.env,
     runId: input.runId,
   }).catch((error) => {
-    console.warn('[coordinator] workflow platform retry claim failed', {
-      runId: input.runId,
-      error: error instanceof Error ? error.message : String(error),
-    });
+    recordCoordinatorEvent(
+      'warn',
+      'coordinator.workflow_platform_retry.claim_failed',
+      '[coordinator] workflow platform retry claim failed',
+      {
+        runId: input.runId,
+        error: error instanceof Error ? error.message : String(error),
+      },
+    );
     return null;
   });
   if (!claim?.claimed || !claim.params) {
@@ -1968,13 +2068,18 @@ async function callRuntimeApiFromCoordinator(input: {
             '',
         ) || null
       : null;
-  console.info('[coordinator.runtime_api.breadcrumb]', {
-    phase: 'request',
-    action,
-    runId,
-    requestId,
-    baseOrigin: safeOrigin(input.baseUrl),
-  });
+  recordCoordinatorEvent(
+    'info',
+    'coordinator.runtime_api.breadcrumb',
+    '[coordinator.runtime_api.breadcrumb]',
+    {
+      phase: 'request',
+      action,
+      runId,
+      requestId,
+      baseOrigin: safeOrigin(input.baseUrl),
+    },
+  );
   const response = await input.env.HARNESS.runtimeApiCall({
     contract: PLAY_RUNTIME_CONTRACT,
     executorToken: input.executorToken,
@@ -1987,15 +2092,20 @@ async function callRuntimeApiFromCoordinator(input: {
     },
   });
   recordTiming('coordinator.runtime_api.fetch', fetchStartedAt);
-  console.info('[coordinator.runtime_api.breadcrumb]', {
-    phase: 'response',
-    action,
-    runId,
-    requestId,
-    status: response.status,
-    ms: Date.now() - fetchStartedAt,
-    baseOrigin: safeOrigin(input.baseUrl),
-  });
+  recordCoordinatorEvent(
+    'info',
+    'coordinator.runtime_api.breadcrumb',
+    '[coordinator.runtime_api.breadcrumb]',
+    {
+      phase: 'response',
+      action,
+      runId,
+      requestId,
+      status: response.status,
+      ms: Date.now() - fetchStartedAt,
+      baseOrigin: safeOrigin(input.baseUrl),
+    },
+  );
 
   const bodyStartedAt = Date.now();
   const responseBody = response.body;
@@ -3031,7 +3141,9 @@ async function submitChildWorkflowThroughCoordinator(input: {
           childRunId,
           error,
         }).catch((markError) => {
-          console.error(
+          recordCoordinatorEvent(
+            'error',
+            'coordinator.child_workflow_submit.failure_mark_failed',
             '[coordinator] child workflow submit failure mark failed',
             {
               childRunId,
@@ -3088,11 +3200,16 @@ async function submitChildWorkflowThroughCoordinator(input: {
       childRunId,
       error: `workflow submit returned ${response.status}: ${responseText.slice(0, 800)}`,
     }).catch((markError) => {
-      console.error('[coordinator] child workflow submit failure mark failed', {
-        childRunId,
-        error:
-          markError instanceof Error ? markError.message : String(markError),
-      });
+      recordCoordinatorEvent(
+        'error',
+        'coordinator.child_workflow_submit.failure_mark_failed',
+        '[coordinator] child workflow submit failure mark failed',
+        {
+          childRunId,
+          error:
+            markError instanceof Error ? markError.message : String(markError),
+        },
+      );
     });
   }
   return {
@@ -3159,9 +3276,16 @@ export class RuntimeApi extends WorkerEntrypoint<CoordinatorEnv, undefined> {
         .clone()
         .text()
         .catch(() => '');
-      console.error(
-        `[RUNTIME_API] ${incoming.pathname} failed: status=${res.status} ` +
-          `target=${target.toString()} body=${body.slice(0, 500)}`,
+      recordCoordinatorEvent(
+        'error',
+        'coordinator.runtime_api.proxy_failed',
+        '[RUNTIME_API] request failed',
+        {
+          path: incoming.pathname,
+          status: res.status,
+          targetOrigin: target.origin,
+          body: body.slice(0, 500),
+        },
       );
     }
     return res;
@@ -3394,10 +3518,15 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
           status: 'running',
           ts: Date.now(),
         }).catch((error) => {
-          console.warn('[coordinator] workflow entry status event failed', {
-            runId: entryTrace.runId,
-            error: error instanceof Error ? error.message : String(error),
-          });
+          recordCoordinatorEvent(
+            'warn',
+            'coordinator.workflow_entry.status_event_failed',
+            '[coordinator] workflow entry status event failed',
+            {
+              runId: entryTrace.runId,
+              error: error instanceof Error ? error.message : String(error),
+            },
+          );
         }),
       );
     }
@@ -3449,7 +3578,9 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
           event: dispatchedEvent,
           error: hydrateError,
         }).catch((markError) => {
-          console.error(
+          recordCoordinatorEvent(
+            'error',
+            'coordinator.db_session_expired.failure_forward_failed',
             '[coordinator] failed to forward expired-db-session run failure',
             {
               runId: entryTrace.runId,
@@ -3586,7 +3717,9 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                     });
                   }
                 } catch (childTerminalError) {
-                  console.warn(
+                  recordCoordinatorEvent(
+                    'warn',
+                    'coordinator.child_terminal.ledger_append_failed',
                     '[coordinator] child terminal ledger append failed; preserving coordinator terminal cache',
                     {
                       runId: runIdForTrace,
@@ -3624,7 +3757,7 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                     {
                       graphHash,
                       runId: runIdForTrace,
-                      message:
+                      error:
                         terminalError instanceof Error
                           ? terminalError.message
                           : String(terminalError),
@@ -3641,7 +3774,9 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
               } catch (innerError) {
                 const failure =
                   normalizeCoordinatorWorkflowRuntimeFailure(innerError);
-                console.error(
+                recordCoordinatorEvent(
+                  'error',
+                  'coordinator.dynamic_workflow.runner_failed',
                   '[coordinator] DynamicWorkflow runner.run threw',
                   {
                     graphHash,
@@ -3668,7 +3803,9 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                     event: innerEvent,
                     error: innerError,
                   }).catch((markError) => {
-                    console.error(
+                    recordCoordinatorEvent(
+                      'error',
+                      'coordinator.dynamic_workflow.failure_forward_failed',
                       '[coordinator] failed to forward DynamicWorkflow runner error',
                       {
                         graphHash,
@@ -3685,7 +3822,9 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                     error: failure.message,
                   }).catch(() => undefined);
                 } else {
-                  console.warn(
+                  recordCoordinatorEvent(
+                    'warn',
+                    'coordinator.dynamic_workflow.platform_reset_retrying',
                     '[coordinator] DynamicWorkflow platform reset will be retried; not publishing durable run.failed',
                     {
                       graphHash,
@@ -4133,11 +4272,16 @@ function coordinatorWorkflowRouteErrorResponse(input: {
   const message =
     input.error instanceof Error ? input.error.message : String(input.error);
   const phase = `coordinator.${input.action || 'unknown'}`;
-  console.error('[coordinator.workflow_route.error]', {
-    runId: input.runId,
-    action: input.action,
-    error: message,
-  });
+  recordCoordinatorEvent(
+    'error',
+    'coordinator.workflow_route.error',
+    '[coordinator.workflow_route.error]',
+    {
+      runId: input.runId,
+      action: input.action,
+      error: message,
+    },
+  );
   if (
     input.action === 'submit' &&
     isTenantStorageDegradationError(input.error)
@@ -4151,12 +4295,17 @@ function coordinatorWorkflowRouteErrorResponse(input: {
     // actions (status/result/tail/cancel/signal) run against an already-active,
     // possibly-billing run, so surfacing "storage not ready, nothing billed,
     // run db repair" there would be false and alarming on a healthy run.
-    console.error('[coordinator.workflow_route.storage_not_ready]', {
-      runId: input.runId,
-      action: input.action,
-      phase,
-      error: message,
-    });
+    recordCoordinatorEvent(
+      'error',
+      'coordinator.workflow_route.storage_not_ready',
+      '[coordinator.workflow_route.storage_not_ready]',
+      {
+        runId: input.runId,
+        action: input.action,
+        phase,
+        error: message,
+      },
+    );
     return Response.json(
       {
         error: {
@@ -4198,7 +4347,7 @@ function coordinatorRouteErrorResponse(input: {
 }): Response {
   const message =
     input.error instanceof Error ? input.error.message : String(input.error);
-  console.error(input.logTag, {
+  recordCoordinatorEvent('error', 'coordinator.route.error', input.logTag, {
     runId: input.runId,
     phase: input.phase,
     error: message,
@@ -4358,7 +4507,9 @@ async function handleWorkflowRoute(input: {
           // logs. Log the tenant-storage classification loudly so the real
           // cause (and the WORKSPACE_STORAGE_NOT_READY repair path) is visible.
           if (storageNotReady) {
-            console.error(
+            recordCoordinatorEvent(
+              'error',
+              'coordinator.harness_prewarm_postgres.storage_not_ready',
               '[coordinator.harness_prewarm_postgres.storage_not_ready]',
               {
                 runId: submittedRunId,
@@ -4414,11 +4565,16 @@ async function handleWorkflowRoute(input: {
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : String(error);
-      console.error('[coordinator] workflow retry state persistence failed', {
-        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
-        runId: submittedRunId,
-        error: errorMessage,
-      });
+      recordCoordinatorEvent(
+        'error',
+        'coordinator.workflow_retry_state.persistence_failed',
+        '[coordinator] workflow retry state persistence failed',
+        {
+          code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
+          runId: submittedRunId,
+          error: errorMessage,
+        },
+      );
       recordSubmitTiming({
         phase: 'coordinator.retry_state_persistence',
         ms: 0,
@@ -4561,16 +4717,23 @@ async function handleWorkflowRoute(input: {
           instanceId: instance.id,
         });
       } catch (error) {
-        console.warn('[coordinator] workflow instance id record failed', {
-          runId: submittedRunId,
-          instanceId: instance?.id ?? null,
-          error: error instanceof Error ? error.message : String(error),
-        });
+        recordCoordinatorEvent(
+          'warn',
+          'coordinator.workflow_instance_id.record_failed',
+          '[coordinator] workflow instance id record failed',
+          {
+            runId: submittedRunId,
+            instanceId: instance?.id ?? null,
+            error: error instanceof Error ? error.message : String(error),
+          },
+        );
         await releaseWorkflowSubmitClaim({
           env,
           runId: submittedRunId,
         }).catch((releaseError) => {
-          console.warn(
+          recordCoordinatorEvent(
+            'warn',
+            'coordinator.workflow_submit_claim.release_failed',
             '[coordinator] workflow submit claim release after instance record failure failed',
             {
               runId: submittedRunId,
@@ -4678,19 +4841,24 @@ async function handleWorkflowRoute(input: {
         ms: Date.now() - startedAt,
         extra: { status: submitResponse.status, childRunId },
       });
-      console.info('[play.runtime.span]', {
-        event: 'play.runtime.span',
-        phase: 'coordinator_child_submit',
-        runId,
-        parentRunId: runId,
-        childRunId,
-        playName: childPlayName,
-        ms: Date.now() - startedAt,
-        status: submitResponse.ok ? 'ok' : 'failed',
-        ...(submitResponse.ok
-          ? {}
-          : { errorCode: 'COORDINATOR_CHILD_SUBMIT_FAILED' }),
-      });
+      recordCoordinatorEvent(
+        'info',
+        'play.runtime.span',
+        '[play.runtime.span]',
+        {
+          event: 'play.runtime.span',
+          phase: 'coordinator_child_submit',
+          runId,
+          parentRunId: runId,
+          childRunId,
+          playName: childPlayName,
+          ms: Date.now() - startedAt,
+          status: submitResponse.ok ? 'ok' : 'failed',
+          ...(submitResponse.ok
+            ? {}
+            : { errorCode: 'COORDINATOR_CHILD_SUBMIT_FAILED' }),
+        },
+      );
       if (!submitResponse.ok) {
         return new Response(responseText, {
           status: submitResponse.status,
@@ -4716,11 +4884,16 @@ async function handleWorkflowRoute(input: {
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error('[coordinator.child_submit.error]', {
-        runId,
-        ms: Date.now() - startedAt,
-        error: message,
-      });
+      recordCoordinatorEvent(
+        'error',
+        'coordinator.child_submit.error',
+        '[coordinator.child_submit.error]',
+        {
+          runId,
+          ms: Date.now() - startedAt,
+          error: message,
+        },
+      );
       return Response.json(
         {
           error: {
@@ -4883,10 +5056,15 @@ async function handleWorkflowRoute(input: {
       ).catch((error: unknown) => {
         // Tolerated: better to risk a harmless terminal-over-terminal
         // overwrite than to skip the cancelled write and hang watchers.
-        console.warn('[coordinator] terminal state read before cancel failed', {
-          runId,
-          error: error instanceof Error ? error.message : String(error),
-        });
+        recordCoordinatorEvent(
+          'warn',
+          'coordinator.cancel.terminal_state_read_failed',
+          '[coordinator] terminal state read before cancel failed',
+          {
+            runId,
+            error: error instanceof Error ? error.message : String(error),
+          },
+        );
         return null;
       });
       if (!existingTerminal) {
@@ -4901,10 +5079,15 @@ async function handleWorkflowRoute(input: {
           // hang on 'running' forever without the terminal event.
           const message =
             error instanceof Error ? error.message : String(error);
-          console.error('[coordinator] cancel terminal state write failed', {
-            runId,
-            error: message,
-          });
+          recordCoordinatorEvent(
+            'error',
+            'coordinator.cancel.terminal_state_write_failed',
+            '[coordinator] cancel terminal state write failed',
+            {
+              runId,
+              error: message,
+            },
+          );
           return Response.json(
             {
               runId,
@@ -4944,11 +5127,16 @@ async function handleWorkflowRoute(input: {
           eventKey,
           data: body.data ?? body,
         }).catch((error: unknown) => {
-          console.warn('[coordinator] child terminal cache write failed', {
-            runId,
-            eventKey,
-            error: error instanceof Error ? error.message : String(error),
-          });
+          recordCoordinatorEvent(
+            'warn',
+            'coordinator.child_terminal.cache_write_failed',
+            '[coordinator] child terminal cache write failed',
+            {
+              runId,
+              eventKey,
+              error: error instanceof Error ? error.message : String(error),
+            },
+          );
         });
       }
       await instance.sendEvent({
@@ -5048,7 +5236,9 @@ async function handleWorkflowRoute(input: {
               message,
             )
           ) {
-            console.warn(
+            recordCoordinatorEvent(
+              'warn',
+              'coordinator.permanent_error.terminate_failed',
               '[coordinator] terminate-after-permanent-error failed',
               {
                 runId,
@@ -5462,12 +5652,20 @@ export class TenantWorkflow extends WorkflowEntrypoint {
       })).catch(() => null);
     }
     console.log("[perf-trace] " + JSON.stringify({
+      telemetrySchemaVersion: 1,
+      timestamp: new Date().toISOString(),
+      service: "play-runtime",
+      component: "coordinator-warmup",
+      event: "dynamic_worker.warmup_run",
+      tag: "[perf-trace]",
       ts: Date.now(),
       source: "dynamic_worker",
       runId,
       phase: "dynamic_worker.warmup_run",
       ms: Date.now() - startedAt,
-      graphHash: "coordinator-warmup-v1"
+      graphHash: "coordinator-warmup-v1",
+      telemetryKind: "log",
+      telemetryLevel: "info"
     }));
     return { ok: true, warmup: true };
   }
@@ -5540,15 +5738,20 @@ async function handleStagedFilePut(
     }
     const existing = await headExistingStagedFile(env, key, expectedBytes);
     if (existing.exists) {
-      console.info('[perf][coordinator.staged_file_put]', {
-        key,
-        bytes: expectedBytes,
-        headMs: existing.ms,
-        putMs: 0,
-        ms: existing.ms,
-        transport: 'raw',
-        skipped: true,
-      });
+      recordCoordinatorEvent(
+        'info',
+        'coordinator.staged_file_put',
+        '[perf][coordinator.staged_file_put]',
+        {
+          key,
+          bytes: expectedBytes,
+          headMs: existing.ms,
+          putMs: 0,
+          ms: existing.ms,
+          transport: 'raw',
+          skipped: true,
+        },
+      );
       return Response.json({
         ok: true,
         key,
@@ -5571,14 +5774,19 @@ async function handleStagedFilePut(
       httpMetadata: { contentType },
     });
     const putMs = Date.now() - putStartedAt;
-    console.info('[perf][coordinator.staged_file_put]', {
-      key,
-      bytes: bytes.byteLength,
-      readMs,
-      putMs,
-      ms: readMs + putMs,
-      transport: 'raw',
-    });
+    recordCoordinatorEvent(
+      'info',
+      'coordinator.staged_file_put',
+      '[perf][coordinator.staged_file_put]',
+      {
+        key,
+        bytes: bytes.byteLength,
+        readMs,
+        putMs,
+        ms: readMs + putMs,
+        transport: 'raw',
+      },
+    );
     return Response.json({
       ok: true,
       key,
@@ -5615,15 +5823,20 @@ async function handleStagedFilePut(
   }
   const existing = await headExistingStagedFile(env, key, expectedBytes);
   if (existing.exists) {
-    console.info('[perf][coordinator.staged_file_put]', {
-      key,
-      bytes: expectedBytes,
-      headMs: existing.ms,
-      putMs: 0,
-      ms: existing.ms,
-      transport: 'base64',
-      skipped: true,
-    });
+    recordCoordinatorEvent(
+      'info',
+      'coordinator.staged_file_put',
+      '[perf][coordinator.staged_file_put]',
+      {
+        key,
+        bytes: expectedBytes,
+        headMs: existing.ms,
+        putMs: 0,
+        ms: existing.ms,
+        transport: 'base64',
+        skipped: true,
+      },
+    );
     return Response.json({
       ok: true,
       key,
@@ -5646,13 +5859,18 @@ async function handleStagedFilePut(
     httpMetadata: { contentType },
   });
   const putMs = Date.now() - putStartedAt;
-  console.info('[perf][coordinator.staged_file_put]', {
-    key,
-    bytes: bytes.byteLength,
-    decodeMs,
-    putMs,
-    ms: decodeMs + putMs,
-  });
+  recordCoordinatorEvent(
+    'info',
+    'coordinator.staged_file_put',
+    '[perf][coordinator.staged_file_put]',
+    {
+      key,
+      bytes: bytes.byteLength,
+      decodeMs,
+      putMs,
+      ms: decodeMs + putMs,
+    },
+  );
   return Response.json({
     ok: true,
     key,
@@ -5931,7 +6149,9 @@ function makeCoordinatorControlBinding():
   if (typeof ctor !== 'function') {
     if (!loggedMissingCoordinatorControlExport) {
       loggedMissingCoordinatorControlExport = true;
-      console.warn(
+      recordCoordinatorEvent(
+        'warn',
+        'coordinator.control_export.missing',
         '[coordinator] CoordinatorControl is not registered on cloudflare:workers exports; using public coordinator transport.',
       );
     }