brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-7XOPAB5Q.js → chunk-4P2HHGAX.mjs}

@@ -2,25 +2,25 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-XDZOO4L5.js";
+} from "./chunk-EJ6BPYVR.mjs";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-7LVI2GIN.js";
+} from "./chunk-GYM3LLGS.mjs";
 import {
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncSucceed,
   asyncSync
-} from "./chunk-PNVFW245.js";
+} from "./chunk-36I3M4UC.mjs";
 import {
   Schema,
   parseConfig
-} from "./chunk-TDVMADDN.js";
+} from "./chunk-DNFJLJMW.mjs";
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {
@@ -1462,6 +1462,7 @@ var object = Schema.custom(
 );
 var falseOrObject = Schema.union([Schema.literal(false), object]);
 var ratio = Schema.number({ min: 0, max: 1 });
+var logLevel = Schema.enum(["debug", "info", "warn", "error"]);
 var retryOptions = Schema.object({
   attempts: Schema.number({ min: 0, int: true }).optional(),
   initialDelayMs: Schema.number({ min: 0, int: true }).optional(),
@@ -1523,11 +1524,78 @@ var observabilityOptions = Schema.object({
   childName: fn.optional(),
   onFlushError: fn.optional()
 }, { unknownKeys: "passthrough" });
+var httpObservabilityOptions = Schema.object({
+  metrics: falseOrObject.optional(),
+  logs: Schema.union([
+    Schema.literal(false),
+    Schema.object({
+      requestLevel: Schema.union([logLevel, Schema.literal(false)]).optional(),
+      responseLevel: Schema.union([logLevel, Schema.literal(false)]).optional(),
+      errorLevel: Schema.union([logLevel, Schema.literal(false)]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  spans: Schema.union([
+    Schema.literal(false),
+    Schema.object({
+      name: Schema.union([Schema.string({ minLength: 1 }), fn]).optional(),
+      attributes: Schema.union([object, fn]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  adaptiveLimiter: Schema.union([
+    Schema.boolean(),
+    Schema.object({
+      enabled: Schema.boolean().optional(),
+      includeKeyLabel: Schema.boolean().optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  policy: Schema.union([
+    Schema.boolean(),
+    Schema.object({
+      enabled: Schema.boolean().optional(),
+      labelKeys: Schema.array(Schema.enum(["preset", "lane", "poolKey", "dedupKey", "priority", "retry"])).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  injectTraceHeaders: Schema.boolean().optional(),
+  includeHostLabel: Schema.boolean().optional(),
+  route: Schema.union([Schema.string({ minLength: 1 }), fn]).optional(),
+  clock: fn.optional(),
+  durationBuckets: Schema.array(Schema.number({ min: 0 }).refine((n) => n > 0, "duration bucket must be > 0")).optional()
+}, { unknownKeys: "passthrough" });
 function validateObservabilityOptions(options) {
   parseConfig("ObservabilityOptions", observabilityOptions, options);
 }
+function validateHttpObservabilityOptions(options) {
+  parseConfig("HttpObservabilityOptions", httpObservabilityOptions, options);
+}
 
 // src/observability/setup.ts
+var DEFAULT_OTLP_SIGNALS = ["metrics", "traces", "logs"];
+function makeOtlpOptions(input) {
+  const endpoint = normalizeOtlpEndpoint(input.endpoint);
+  const signals = input.signals ?? DEFAULT_OTLP_SIGNALS;
+  return {
+    ...signals.includes("metrics") ? { metricsUrl: `${endpoint}/v1/metrics` } : {},
+    ...signals.includes("traces") ? { tracesUrl: `${endpoint}/v1/traces` } : {},
+    ...signals.includes("logs") ? { logsUrl: `${endpoint}/v1/logs` } : {},
+    ...input.headers ? { headers: input.headers } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.retry ? { retry: input.retry } : {},
+    ...input.pipeline ? { pipeline: input.pipeline } : {}
+  };
+}
+function normalizeOtlpEndpoint(endpoint) {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  const normalized = trimmed.slice(0, end);
+  if (!normalized) {
+    throw new Error("makeOtlpOptions endpoint must not be empty");
+  }
+  return normalized;
+}
 function makeObservability(options = {}) {
   validateObservabilityOptions(options);
   const serviceName = options.serviceName ?? "brass-runtime";
@@ -1861,12 +1929,13 @@ function makeRuntimeTraceIdGenerator() {
     newSpanId: () => randomHexId(16)
   };
 }
+var HEX_BYTE = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
 function randomHexId(length) {
   const cryptoLike = globalThis.crypto;
   if (typeof cryptoLike?.getRandomValues === "function") {
     const bytes = new Uint8Array(Math.ceil(length / 2));
     cryptoLike.getRandomValues(bytes);
-    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+    return bytesToHex(bytes, length);
   }
   if (typeof cryptoLike?.randomUUID === "function") {
     const hex = cryptoLike.randomUUID().replace(/-/g, "");
@@ -1878,6 +1947,13 @@ function randomHexId(length) {
   }
   return out.slice(0, length);
 }
+function bytesToHex(bytes, length) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += HEX_BYTE[bytes[i]];
+  }
+  return out.length === length ? out : out.slice(0, length);
+}
 
 // src/observability/request.ts
 function makeRequestObservabilityContext(observability, input = {}) {
@@ -2134,6 +2210,8 @@ export {
   makeCardinalityLimitedMetrics,
   normalizeHttpRoute,
   sanitizeHttpTarget,
+  validateHttpObservabilityOptions,
+  makeOtlpOptions,
   makeObservability,
   resolveRequestTraceSeed,
   resolveRequestBaggage,