@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/tenant/worker.js

@@ -51,16 +51,9 @@
 import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
 import { RunAbort } from "@nylorun/harness/api";
+import { hostTuning, MAX_TIMER_MS } from "../tuning.js";
 /** This process's Worker id: the `owner` it writes on the sessions it advances (§10.6). */
 export const WORKER_ID = `worker-${hostname()}-${process.pid}-${randomBytes(4).toString("hex")}`;
-/**
- * Default advance deadline: 50 minutes, below the one-hour inactivity and abort timeouts the
- * Restate adapter sets on the session object, so an advance always ends before Restate gives
- * up on it.
- */
-export const DEFAULT_ADVANCE_DEADLINE_MS = 50 * 60_000;
-/** Default time an aborted advance has to settle before it is abandoned. */
-export const DEFAULT_ADVANCE_GRACE_MS = 30_000;
 /**
  * The abort reason of an advance. A harness run's reason (`RunAbort`) has the same kinds, so the
  * executors read either one.
@@ -109,8 +102,8 @@ export class TenantWorkers {
     graceMs;
     constructor(options = {}) {
         this.options = options;
-        this.deadlineMs = positive("advanceDeadlineMs", options.advanceDeadlineMs ?? DEFAULT_ADVANCE_DEADLINE_MS);
-        this.graceMs = positive("advanceGraceMs", options.advanceGraceMs ?? DEFAULT_ADVANCE_GRACE_MS);
+        this.deadlineMs = positive("advanceDeadlineMs", options.advanceDeadlineMs ?? hostTuning().execution.advanceDeadlineMs);
+        this.graceMs = positive("advanceGraceMs", options.advanceGraceMs ?? hostTuning().execution.advanceGraceMs);
     }
     /** Registers an open Tenant's worker; the returned function unregisters exactly it. */
     register(tenantId, worker) {
@@ -187,10 +180,8 @@ export class TenantWorkers {
         }
     }
 }
-/** The longest delay `setTimeout` keeps (about 24.8 days). */
-const MAX_TIMEOUT_MS = 2 ** 31 - 1;
 function positive(name, value) {
-    if (!Number.isFinite(value) || value <= 0 || value > MAX_TIMEOUT_MS)
-        throw new Error(`${name} must be positive and at most ${MAX_TIMEOUT_MS}`);
+    if (!Number.isFinite(value) || value <= 0 || value > MAX_TIMER_MS)
+        throw new Error(`${name} must be positive and at most ${MAX_TIMER_MS}`);
     return value;
 }

package/dist/traces/ids.js

@@ -45,7 +45,11 @@ export function parseTraceparent(value) {
         return undefined;
     return { traceId: traceId, spanId: spanId };
 }
-/** The most `tracestate` the Runtime keeps (W3C: 32 members, 512 characters is enough). */
+/**
+ * The most `tracestate` the Runtime keeps: W3C Trace Context (Level 1, section 3.3.1.1) has
+ * vendors propagate at least 512 characters of it, and lets one cut what is past that. A
+ * standard's constant, not a limit (B15).
+ */
 const TRACESTATE_MAX = 512;
 /**
  * The trace context a request's headers carry (R7.4), or undefined without a valid

package/dist/traces/map.d.ts

@@ -25,7 +25,8 @@
  * never carries a person's id (`ownerUserId`, a subject, who approved), an identity header, an
  * idempotency key or a credential value (the log holds none). Content (what a person said, the
  * model's output, tool results and error messages) is left out unless the installation opts in
- * per kind (`TraceContent`), each value cut at 8 KiB. Prompts are not in the log, so never here.
+ * per kind (`TraceContent`), each value cut at the Tenant's Runtime limit `traceContentBytes`
+ * (`SpanSettings.contentBytes`). Prompts are not in the log, so never here.
  */
 import type { LiveEvent } from "@nylorun/core/contracts";
 import { type TraceKey } from "./ids.js";
@@ -39,8 +40,6 @@ export declare const GENAI_SEMCONV = "open-telemetry/semantic-conventions-genai@
 export declare const TRACE_CONTENT_KINDS: readonly ["user", "outputs", "tool-results", "errors"];
 export type TraceContentKind = (typeof TRACE_CONTENT_KINDS)[number];
 export type TraceContent = ReadonlySet<TraceContentKind>;
-/** The most bytes of one content attribute or status message. */
-export declare const CONTENT_MAX_BYTES: number;
 /** OTLP span kinds and status codes (opentelemetry-proto `trace.proto`). */
 export declare const SPAN_KIND: {
     readonly internal: 1;
@@ -93,10 +92,14 @@ export interface TurnTrace {
     /** What a person sent, as `gen_ai.input.messages` (only with `user` content). */
     readonly input?: string;
 }
-/** How spans are made: the trace key and the content the installation exports. */
+/**
+ * How spans are made: the trace key, the content the installation exports, and the most UTF-8
+ * bytes of one content attribute (the Tenant's Runtime limit `traceContentBytes`).
+ */
 export interface SpanSettings {
     readonly key: TraceKey;
     readonly content: TraceContent;
+    readonly contentBytes: number;
 }
 /**
  * The trace of turn `turnId` of session `sessionId`, from its `command.message` when the log has
@@ -109,5 +112,5 @@ export declare function turnTraceOf(settings: SpanSettings, ids: {
 }, message?: Pick<LiveEvent, "payload" | "principal"> | undefined): TurnTrace;
 /** The span `row` makes in its turn's trace, or undefined when it makes none. */
 export declare function spanOf(row: LiveEvent, turn: TurnTrace, settings: SpanSettings): OtlpSpan | undefined;
-/** `value` cut to `CONTENT_MAX_BYTES` of UTF-8, never in the middle of a character. */
-export declare function truncate(value: string): string;
+/** `value` cut to `maxBytes` of UTF-8, never in the middle of a character. */
+export declare function truncate(value: string, maxBytes: number): string;

package/dist/traces/map.js

@@ -7,8 +7,6 @@ export const GENAI_SEMCONV = "open-telemetry/semantic-conventions-genai@6fd0d763
  * (error messages; their codes are always exported).
  */
 export const TRACE_CONTENT_KINDS = ["user", "outputs", "tool-results", "errors"];
-/** The most bytes of one content attribute or status message. */
-export const CONTENT_MAX_BYTES = 8 * 1024;
 /** OTLP span kinds and status codes (opentelemetry-proto `trace.proto`). */
 export const SPAN_KIND = { internal: 1, client: 3 };
 export const STATUS = { unset: 0, ok: 1, error: 2 };
@@ -19,7 +17,7 @@ export const STATUS = { unset: 0, ok: 1, error: 2 };
 export function turnTraceOf(settings, ids, message) {
     const payload = (message?.payload ?? {});
     const inbound = typeof payload.trace?.traceparent === "string" ? parseTraceparent(payload.trace.traceparent) : undefined;
-    const input = settings.content.has("user") && message ? userMessages(payload) : undefined;
+    const input = settings.content.has("user") && message ? userMessages(payload, settings.contentBytes) : undefined;
     return {
         traceId: inbound?.traceId ?? traceIdOf(settings.key, ids.tenantId, ids.sessionId, ids.turnId),
         spanId: turnSpanOf(settings.key, ids.turnId),
@@ -52,7 +50,7 @@ export function spanOf(row, turn, settings) {
     const effectSpan = (effectId) => typeof effectId === "string" && effectId.length > 0
         ? effectSpanOf(settings.key, effectId)
         : eventSpanOf(settings.key, row.sessionId, row.seq);
-    const content = (kind, value) => settings.content.has(kind) && value !== undefined ? truncate(typeof value === "string" ? value : JSON.stringify(value)) : undefined;
+    const content = (kind, value) => settings.content.has(kind) && value !== undefined ? truncate(typeof value === "string" ? value : JSON.stringify(value), settings.contentBytes) : undefined;
     switch (row.type) {
         case "turn.completed":
         case "turn.failed":
@@ -132,7 +130,6 @@ export function spanOf(row, turn, settings) {
                 .str("nylorun.effect.id", p.effectId)
                 .int("nylorun.effect.window_ms", p.durationMs)
                 .str("nylorun.compaction.trigger", row.type === "context.compacted" ? p.trigger : undefined)
-                .bool("nylorun.compaction.partial", row.type === "context.compacted" && p.partial === true ? true : undefined)
                 .str("error.type", row.type === "model.failed" ? p.code : undefined)
                 .str("gen_ai.output.messages", output);
             return {
@@ -158,6 +155,7 @@ export function spanOf(row, turn, settings) {
                 .str("gen_ai.agent.id", p.agent?.id)
                 .str("nylorun.tool.kind", kind)
                 .str("nylorun.tool.server", p.server)
+                .str("nylorun.tool.identity", p.tool)
                 .str("nylorun.tool.status", p.status)
                 .int("nylorun.tool.attempts", p.attempts)
                 .int("nylorun.tool.redacted", p.redacted)
@@ -264,7 +262,7 @@ function textPart(value) {
     return { type: "text", content: typeof value === "string" ? value : JSON.stringify(value) };
 }
 /** What a person sent (`command.message`), as `gen_ai.input.messages`. */
-function userMessages(payload) {
+function userMessages(payload, maxBytes) {
     const parts = typeof payload.content === "string"
         ? [{ type: "text", content: payload.content }]
         : Array.isArray(payload.parts)
@@ -274,14 +272,14 @@ function userMessages(payload) {
             : payload.data !== undefined
                 ? [textPart(payload.data)]
                 : undefined;
-    return parts ? truncate(JSON.stringify([{ role: "user", parts }])) : undefined;
+    return parts ? truncate(JSON.stringify([{ role: "user", parts }]), maxBytes) : undefined;
 }
-/** `value` cut to `CONTENT_MAX_BYTES` of UTF-8, never in the middle of a character. */
-export function truncate(value) {
+/** `value` cut to `maxBytes` of UTF-8, never in the middle of a character. */
+export function truncate(value, maxBytes) {
     const bytes = Buffer.from(value, "utf8");
-    if (bytes.length <= CONTENT_MAX_BYTES)
+    if (bytes.length <= maxBytes)
         return value;
-    let end = CONTENT_MAX_BYTES;
+    let end = maxBytes;
     // Back up over continuation bytes (10xxxxxx) to the start of the cut character.
     while (end > 0 && (bytes[end] & 0xc0) === 0x80)
         end -= 1;

package/dist/traces/otlp.d.ts

@@ -28,11 +28,11 @@ export interface OtlpPosterOptions {
     /** `OTEL_EXPORTER_OTLP_HEADERS`. */
     readonly headers?: Readonly<Record<string, string>>;
     readonly resource: TraceResource;
-    /** Tries after the first, for a `429`, a `5xx` or a lost connection. Default 3. */
+    /** Tries after the first, for a `429`, a `5xx` or a lost connection. Default `traces.retries` (Host tuning, 3). */
     readonly retries?: number;
-    /** The wait before the first retry, doubled for each one after. Default 500 ms. */
+    /** The wait before the first retry, doubled for each one after. Default `traces.backoffMs` (500 ms). */
     readonly backoffMs?: number;
-    /** How long one request may take. Default 10 s. */
+    /** How long one request may take. Default `traces.timeoutMs` (10 s). */
     readonly timeoutMs?: number;
     readonly fetch?: typeof fetch;
     readonly log?: (message: string, fields?: Record<string, unknown>) => void;

package/dist/traces/otlp.js

@@ -10,6 +10,7 @@
  */
 import { RUNTIME_VERSION } from "../version.js";
 import { GENAI_SEMCONV } from "./map.js";
+import { hostTuning } from "../tuning.js";
 export const DEFAULT_SERVICE_NAME = "nylorun";
 /** The instrumentation scope of every span. */
 const SCOPE = { name: "@nylorun/runtime", version: RUNTIME_VERSION };
@@ -27,9 +28,10 @@ export function resourceSpans(resource, spans) {
 }
 export function createOtlpPoster(options) {
     const send = options.fetch ?? fetch;
-    const retries = options.retries ?? 3;
-    const backoffMs = options.backoffMs ?? 500;
-    const timeoutMs = options.timeoutMs ?? 10_000;
+    const tuning = hostTuning().traces;
+    const retries = options.retries ?? tuning.retries;
+    const backoffMs = options.backoffMs ?? tuning.backoffMs;
+    const timeoutMs = options.timeoutMs ?? tuning.timeoutMs;
     const log = options.log ?? (() => { });
     return async (spans, signal) => {
         if (spans.length === 0)

package/dist/traces/projector.d.ts

@@ -27,16 +27,21 @@ export interface TraceProjectorOptions {
     readonly post: OtlpPoster;
     /** The Tenant's trace key (`traces/key.ts`). */
     readonly key: () => Promise<TraceKey>;
+    /** The Tenant's Runtime limit `traceContentBytes`, read for each transaction mapped. */
+    readonly contentBytes: () => Promise<number>;
     /** The `command.message` that started turn `turnId`, or undefined when the log has none. */
     readonly turnMessage: (sessionId: string, turnId: string) => Promise<LiveEvent | undefined>;
     readonly content: TraceContent;
-    /** Spans per post. Default 512. */
+    /** Spans per post. Default `traces.batchSpans` (Host tuning, 512). */
     readonly maxBatch?: number;
-    /** How long a span waits for its batch to fill. Default 2 s. */
+    /** How long a span waits for its batch to fill. Default `traces.batchDelayMs` (2 s). */
     readonly maxDelayMs?: number;
-    /** Spans waiting while a post is out, past which the waiting ones are dropped. Default 8192. */
+    /**
+     * Spans waiting while a post is out, past which the waiting ones are dropped. Default
+     * `traces.queuedSpansMax` (8192).
+     */
     readonly maxQueuedSpans?: number;
-    /** Turns whose trace is kept. Default 1024. */
+    /** Turns whose trace is kept. Default `traces.turnCacheSize` (1024). */
     readonly turnCacheSize?: number;
     readonly log?: (message: string, fields?: Record<string, unknown>) => void;
 }

package/dist/traces/projector.js

@@ -1,13 +1,15 @@
 import { spanOf, turnTraceOf } from "./map.js";
+import { hostTuning } from "../tuning.js";
 /** The projector's replication slot. */
 export const TRACE_SLOT = "nylorun_trace_export";
 export function createTraceProjector(options) {
     const { source, post } = options;
     const log = options.log ?? (() => { });
-    const maxBatch = options.maxBatch ?? 512;
-    const maxDelayMs = options.maxDelayMs ?? 2000;
-    const maxQueued = options.maxQueuedSpans ?? 8192;
-    const cacheSize = options.turnCacheSize ?? 1024;
+    const tuning = hostTuning().traces;
+    const maxBatch = options.maxBatch ?? tuning.batchSpans;
+    const maxDelayMs = options.maxDelayMs ?? tuning.batchDelayMs;
+    const maxQueued = options.maxQueuedSpans ?? tuning.queuedSpansMax;
+    const cacheSize = options.turnCacheSize ?? tuning.turnCacheSize;
     const turns = new Map();
     const stopping = new AbortController();
     /** Mapped transactions not yet posted, in commit order. */
@@ -17,6 +19,8 @@ export function createTraceProjector(options) {
     let mapping = Promise.resolve();
     let mappingCount = 0;
     let posting;
+    /** Transactions of the batch being posted: not acknowledged until the post settles. */
+    let postingTxs = 0;
     let timer;
     let active = false;
     let confirmed = null;
@@ -45,7 +49,7 @@ export function createTraceProjector(options) {
         const spans = [];
         if (tx.rows.length === 0)
             return spans;
-        const settings = { key: await options.key(), content: options.content };
+        const settings = { key: await options.key(), content: options.content, contentBytes: await options.contentBytes() };
         for (const record of tx.rows) {
             const row = record.body;
             if (!row || typeof row !== "object" || row.turnId == null)
@@ -72,7 +76,7 @@ export function createTraceProjector(options) {
                         if (of !== activation || stopping.signal.aborted)
                             return;
                         log("trace_projector_retry", { message: error instanceof Error ? error.message : String(error) });
-                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        await new Promise((resolve) => setTimeout(resolve, tuning.retryMs));
                     }
                 }
                 if (of !== activation)
@@ -115,6 +119,7 @@ export function createTraceProjector(options) {
         const batch = waiting;
         waiting = [];
         waitingSpans = 0;
+        postingTxs = batch.length;
         posting = (async () => {
             const spans = batch.flatMap((tx) => tx.spans);
             // A post a shutdown cut short is not the collector's failure: those rows go again.
@@ -129,6 +134,7 @@ export function createTraceProjector(options) {
             }
         })().finally(() => {
             posting = undefined;
+            postingTxs = 0;
             schedule();
             settle();
         });
@@ -186,7 +192,7 @@ export function createTraceProjector(options) {
         },
         status: () => ({
             active,
-            pendingTxs: waiting.length + mappingCount,
+            pendingTxs: waiting.length + mappingCount + postingTxs,
             pendingSpans: waitingSpans,
             confirmed,
         }),

package/dist/traces/read.js

@@ -1,9 +1,14 @@
 import { traceKey } from "./key.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { spanOf, turnTraceOf } from "./map.js";
 import { DEFAULT_SERVICE_NAME, resourceSpans } from "./otlp.js";
 /** Turn `turnId`'s spans as an OTLP `ExportTraceServiceRequest`, from its rows in log order. */
 export async function turnTrace(ctx, sessionId, turnId, events) {
-    const settings = { key: await traceKey(ctx.store), content: ctx.traces?.content ?? new Set() };
+    const settings = {
+        key: await traceKey(ctx.store),
+        content: ctx.traces?.content ?? new Set(),
+        contentBytes: (await ctx.store.tx((t) => readRuntimeLimits(t))).traceContentBytes,
+    };
     const message = events.find((event) => event.type === "command.message");
     const turn = turnTraceOf(settings, { tenantId: ctx.store.tenantId, sessionId, turnId }, message);
     const spans = [];