@benchsdk/client 0.2.1 → 0.3.0

package/dist/index.js

@@ -7,6 +7,7 @@ var DEFAULT_READY_POLL_INTERVAL_MS = 1e3;
 var MAX_TASK_RESULT_RECORDS = 5e3;
 var MAX_TASK_RECORD_STEPS = 100;
 var MAX_HEARTBEAT_CONCURRENCY_SAMPLES = 20;
+var MAX_WORKER_LOG_LINES = 1e5;
 var BenchmarkApiError = class extends Error {
   constructor(message, status, body) {
     super(message);
@@ -35,6 +36,9 @@ function getApiKey(input) {
   return input ?? (typeof process !== "undefined" ? process.env.COMPUTESDK_ADMIN_API_KEY ?? process.env.COMPUTESDK_API_KEY : void 0);
 }
 function getErrorCode(error) {
+  if (error instanceof Error && "code" in error && typeof error.code === "string" && error.code) {
+    return error.code;
+  }
   if (error instanceof Error && error.name) return error.name;
   return "ERROR";
 }
@@ -42,6 +46,21 @@ function toJsonObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
+function mergeMeasures(measures, returned) {
+  const merged = { ...measures, ...returned ?? {} };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function implicitTaskStep(record, measures) {
+  return {
+    name: "task",
+    status: record.status === "success" ? "success" : "error",
+    startedAt: record.startedAt,
+    completedAt: record.completedAt,
+    latencyMs: record.latencyMs,
+    errorCode: record.errorCode ?? null,
+    data: Object.keys(measures).length > 0 ? { ...measures } : void 0
+  };
+}
 function validateTaskResults(input) {
   if (input.records.length > MAX_TASK_RESULT_RECORDS) {
     throw new Error(`Benchmark task result batches are limited to ${MAX_TASK_RESULT_RECORDS} records.`);
@@ -87,53 +106,9 @@ function bodySizeBytes(body) {
   if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString()).byteLength;
   return void 0;
 }
-function isDefinedTask(task) {
-  return typeof task === "object" && task !== null && Array.isArray(task.steps);
-}
-function mergeJsonObjects(target, source) {
-  if (!source) return;
-  Object.assign(target, source);
-}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function runWorkerTask(task, context) {
-  if (!isDefinedTask(task)) {
-    return task(context);
-  }
-  const state = {};
-  const data = { taskName: task.name };
-  try {
-    for (const definedStep of task.steps) {
-      const stepData = await context.step(
-        definedStep.name,
-        () => definedStep.fn({
-          assignment: context.assignment,
-          taskIndex: context.taskIndex,
-          state
-        }),
-        definedStep.options
-      );
-      mergeJsonObjects(data, stepData);
-    }
-  } catch (error) {
-    try {
-      await task.options?.cleanup?.({
-        assignment: context.assignment,
-        taskIndex: context.taskIndex,
-        state
-      });
-    } catch {
-    }
-    throw error;
-  }
-  await task.options?.cleanup?.({
-    assignment: context.assignment,
-    taskIndex: context.taskIndex,
-    state
-  });
-  return data;
-}
 async function mapPool(items, concurrency, fn) {
   let nextIndex = 0;
   const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
@@ -410,6 +385,13 @@ function createBenchmarkClient(config = {}) {
         `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/results/imports`
       );
     },
+    async submitRunSummary(benchmarkSlug, runId, input) {
+      await request(
+        "POST",
+        `/benchmarks/${encodePath(benchmarkSlug)}/runs/${encodePath(runId)}/summary`,
+        input
+      );
+    },
     async runWorker(options) {
       if (options.concurrency !== void 0) validatePositiveInteger("concurrency", options.concurrency);
       if (options.batchSize !== void 0) validateBatchSize(options.batchSize);
@@ -521,6 +503,18 @@ function createBenchmarkClient(config = {}) {
         });
       }, options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS);
       resultFlush.unref?.();
+      const workerLogLines = [];
+      let workerLogTruncated = false;
+      function appendWorkerLog(line) {
+        if (workerLogLines.length >= MAX_WORKER_LOG_LINES) {
+          if (!workerLogTruncated) {
+            workerLogTruncated = true;
+            workerLogLines.push("... (worker log truncated)");
+          }
+          return;
+        }
+        workerLogLines.push(line);
+      }
       async function runFinishHook(status) {
         await options.onFinish?.({
           assignment: claimed,
@@ -535,6 +529,19 @@ function createBenchmarkClient(config = {}) {
           }
         });
       }
+      async function uploadWorkerLogArtifact() {
+        if (workerLogLines.length === 0) return;
+        try {
+          await client.uploadWorkerArtifact(options.benchmarkSlug, options.runId, claimed.workerId, {
+            attemptId: claimed.attemptId,
+            kind: "coordinator.log",
+            contentType: "text/plain",
+            name: "worker.log",
+            body: workerLogLines.join("\n") + "\n"
+          });
+        } catch {
+        }
+      }
       try {
         await sendHeartbeat().catch(() => {
         });
@@ -548,6 +555,19 @@ function createBenchmarkClient(config = {}) {
             startedAt: startedAtDate.toISOString()
           };
           const steps = [];
+          const taskMeasures = {};
+          let activeStep = null;
+          function measure(data) {
+            if (activeStep) {
+              activeStep.data = { ...activeStep.data ?? {}, ...data };
+            } else {
+              Object.assign(taskMeasures, data);
+            }
+          }
+          function log(message, meta) {
+            const suffix = meta && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+            appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${message}${suffix}`);
+          }
           async function step(name, fn, stepOptions = {}) {
             const stepStartedAtMs = Date.now();
             const stepRecord = {
@@ -557,6 +577,8 @@ function createBenchmarkClient(config = {}) {
               completedAt: (/* @__PURE__ */ new Date()).toISOString(),
               latencyMs: 0
             };
+            if (stepOptions.timeoutMs !== void 0) stepRecord.timeoutMs = stepOptions.timeoutMs;
+            if (stepOptions.stepConcurrency !== void 0) stepRecord.concurrency = stepOptions.stepConcurrency;
             const shouldReportConcurrency = stepOptions.reportConcurrency ?? true;
             if (shouldReportConcurrency) {
               const stepConcurrency = stepOptions.concurrency ?? workerConcurrency;
@@ -565,16 +587,23 @@ function createBenchmarkClient(config = {}) {
               activeByStep.set(name, (activeByStep.get(name) ?? 0) + 1);
               requestHeartbeat();
             }
+            const previousStep = activeStep;
+            activeStep = stepRecord;
             try {
               if (stepOptions.readiness === "poll") {
                 await waitForStepReady(name, stepOptions);
               }
-              return await fn();
+              const value = await fn();
+              appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${name}`);
+              return value;
             } catch (error) {
               stepRecord.status = "error";
               stepRecord.errorCode = getErrorCode(error);
+              appendWorkerLog(`${(/* @__PURE__ */ new Date()).toISOString()} [task ${taskIndex}] ${name}`);
+              appendWorkerLog(`  error: ${error instanceof Error ? error.message : String(error)}`);
               throw error;
             } finally {
+              activeStep = previousStep;
               stepRecord.completedAt = (/* @__PURE__ */ new Date()).toISOString();
               stepRecord.latencyMs = Date.now() - stepStartedAtMs;
               steps.push(stepRecord);
@@ -591,16 +620,19 @@ function createBenchmarkClient(config = {}) {
             }
           }
           try {
-            const data = await runWorkerTask(options.task, { assignment: claimed, taskIndex, step });
-            record.data = toJsonObject(data);
+            const data = await options.task({ assignment: claimed, taskIndex, step, measure, log });
+            record.data = mergeMeasures(taskMeasures, toJsonObject(data));
           } catch (error) {
             record.status = "error";
             record.errorCode = getErrorCode(error);
-            record.data = { errorMessage: error instanceof Error ? error.message : String(error) };
+            record.data = mergeMeasures(taskMeasures, { errorMessage: error instanceof Error ? error.message : String(error) });
           } finally {
             record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
             record.latencyMs = Date.now() - startedAtMs;
-            record.steps = steps.length > 0 ? steps : void 0;
+            if (steps.length === 0) {
+              steps.push(implicitTaskStep(record, taskMeasures));
+            }
+            record.steps = steps;
             doneCount += 1;
             inFlightCount = Math.max(0, inFlightCount - 1);
             if (record.status !== "success") errorCount += 1;
@@ -632,6 +664,7 @@ function createBenchmarkClient(config = {}) {
         });
         throw error;
       } finally {
+        await uploadWorkerLogArtifact();
         clearInterval(heartbeat);
         clearInterval(resultFlush);
       }
@@ -639,84 +672,6 @@ function createBenchmarkClient(config = {}) {
   };
   return client;
 }
-async function runBenchmarkWorker(config, options) {
-  return createBenchmarkClient(config).runWorker(options);
-}
-function defineStep(name, optionsOrFn, maybeFn) {
-  if (name.trim() === "") {
-    throw new Error("Benchmark step name must be non-empty.");
-  }
-  const hasOptions = typeof optionsOrFn !== "function";
-  const fn = hasOptions ? maybeFn : optionsOrFn;
-  if (!fn) {
-    throw new Error("Benchmark step function is required.");
-  }
-  return { name, options: hasOptions ? optionsOrFn : void 0, fn };
-}
-function defineTask(name, steps, options) {
-  if (name.trim() === "") {
-    throw new Error("Benchmark task name must be non-empty.");
-  }
-  if (steps.length === 0) {
-    throw new Error("Benchmark task must define at least one step.");
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    if (names.has(step.name)) {
-      throw new Error(`Benchmark task step names must be unique. Duplicate step: "${step.name}".`);
-    }
-    names.add(step.name);
-  }
-  return { name, steps, options };
-}
-function defineWorker(options) {
-  const client = options.client ?? createBenchmarkClient();
-  return {
-    run(overrides = {}) {
-      return client.runWorker({
-        benchmarkSlug: options.benchmarkSlug,
-        runId: options.runId,
-        participantSlug: options.participantSlug,
-        processKind: options.processKind,
-        processKey: options.processKey,
-        concurrency: overrides.concurrency ?? options.concurrency,
-        batchSize: overrides.batchSize ?? options.batchSize,
-        flushIntervalMs: overrides.flushIntervalMs ?? options.flushIntervalMs,
-        heartbeatIntervalMs: overrides.heartbeatIntervalMs ?? options.heartbeatIntervalMs,
-        readyPollIntervalMs: overrides.readyPollIntervalMs ?? options.readyPollIntervalMs,
-        onFinish: options.onFinish,
-        task: options.task
-      });
-    }
-  };
-}
-function defineBench(options) {
-  return {
-    slug: options.slug,
-    task: options.task,
-    defineWorker(workerOptions) {
-      const participantSlug = workerOptions.participantSlug ?? options.participantSlug;
-      if (!participantSlug) {
-        throw new Error("Benchmark worker participantSlug is required.");
-      }
-      return defineWorker({
-        benchmarkSlug: options.slug,
-        runId: workerOptions.runId,
-        participantSlug,
-        processKind: workerOptions.processKind,
-        processKey: workerOptions.processKey,
-        concurrency: workerOptions.concurrency ?? options.concurrency,
-        batchSize: workerOptions.batchSize ?? options.batchSize,
-        flushIntervalMs: workerOptions.flushIntervalMs ?? options.flushIntervalMs,
-        heartbeatIntervalMs: workerOptions.heartbeatIntervalMs ?? options.heartbeatIntervalMs,
-        readyPollIntervalMs: workerOptions.readyPollIntervalMs ?? options.readyPollIntervalMs,
-        onFinish: workerOptions.onFinish,
-        client: workerOptions.client ?? options.client,
-        task: workerOptions.task ?? options.task
-      });
-    }
-  };
-}
 
 // src/reporter.ts
 var DEFAULT_REPORTER_BATCH_SIZE = 500;
@@ -749,7 +704,10 @@ var BenchmarkReporter = class _BenchmarkReporter {
         processKey: cfg.processKey
       });
       return assignment ? new _BenchmarkReporter(client, cfg, assignment) : null;
-    } catch {
+    } catch (error) {
+      console.warn(
+        `[benchsdk] failed to claim worker for ${cfg.benchmarkSlug}/${cfg.participantSlug}: ${error instanceof Error ? error.message : String(error)}`
+      );
       return null;
     }
   }
@@ -824,7 +782,12 @@ var BenchmarkReporter = class _BenchmarkReporter {
       contentType: input.contentType,
       metadata: input.metadata,
       body: input.body
-    }).catch(() => null);
+    }).catch((error) => {
+      console.warn(
+        `[benchsdk] failed to upload ${input.kind} artifact for worker ${this.assignment.workerId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    });
   }
   flush(isFinal = false) {
     this.flushChain = this.flushChain.then(async () => {
@@ -840,7 +803,10 @@ var BenchmarkReporter = class _BenchmarkReporter {
             isFinal: isFinal && batch.length === this.pending.length,
             records: batch
           });
-        } catch {
+        } catch (error) {
+          console.warn(
+            `[benchsdk] dropping ${this.pending.length} unsent task result(s) for worker ${this.assignment.workerId}: ${error instanceof Error ? error.message : String(error)}`
+          );
           break;
         }
         this.pending.splice(0, batch.length);
@@ -942,16 +908,38 @@ function createSystemMetricsCollector() {
     }
   };
 }
+
+// src/participants.ts
+function filterParticipantsByEnv(participants) {
+  const available = [];
+  const skipped = [];
+  for (const p of participants) {
+    const missing = p.requiredEnvVars.filter((v) => !process.env[v]);
+    if (missing.length > 0) {
+      skipped.push({ name: p.name, missing });
+    } else {
+      available.push(p);
+    }
+  }
+  return { available, skipped };
+}
+function selectParticipants(all, names) {
+  if (!names) return all;
+  const unknown = names.filter((n) => !all.some((p) => p.name === n));
+  if (unknown.length > 0) {
+    console.error(`Unknown participant(s): ${unknown.join(", ")}`);
+    console.error(`Available: ${all.map((p) => p.name).join(", ")}`);
+    process.exit(1);
+  }
+  return all.filter((p) => names.includes(p.name));
+}
 export {
   BenchmarkApiError,
   BenchmarkReporter,
   claimBenchmarkReporter,
   createBenchmarkClient,
   createSystemMetricsCollector,
-  defineBench,
-  defineStep,
-  defineTask,
-  defineWorker,
-  runBenchmarkWorker
+  filterParticipantsByEnv,
+  selectParticipants
 };
 //# sourceMappingURL=index.js.map