@ooopsstudio/performance 0.9.0

package/dist/chunk-ZAXGEDZW.js

@@ -0,0 +1,1184 @@
+import { createHighResClock, createPerformanceOnError, nsToMs } from './chunk-RY65GERM.js';
+import { hasControlCharacters, sanitizePerformanceEventName, snapshotPerformanceLabels, isSensitivePerformanceKey, sanitizePerformanceLabelValue } from './chunk-2XXIOHOO.js';
+import { isResourceSnapshotEvent, snapshotSafeDBMetadata, deepFreezePerformanceValue, clonePerformanceValue } from './chunk-J6KBSLYO.js';
+import { registerPerformanceDispatcher } from './chunk-MMO5UEUU.js';
+import { ignoreRuntimePromiseRejection, isRuntimePromise, isRuntimeProxy, hasSafeRuntimePrototype } from './chunk-RL2752FW.js';
+import { createHash } from 'crypto';
+
+// src/performance/core/utils/request-helpers.ts
+var UUID_SEGMENT = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var LONG_HEX_SEGMENT = /^[0-9a-f]{16,}$/i;
+var NUMERIC_SEGMENT = /^\d+$/;
+var EMAIL_SEGMENT = /^[^/@\s]+@[^/@\s]+\.[^/@\s]+$/u;
+var OPAQUE_SEGMENT = /^[a-z0-9+_=-]{24,}$/iu;
+var HTTP_OUTCOMES = /* @__PURE__ */ new Set(["ok", "client_error", "server_error", "timeout", "aborted"]);
+var MAX_NORMALIZED_ROUTE_LENGTH = 256;
+var isDynamicRouteSegment = (segment) => {
+  let decoded = segment;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+  }
+  return UUID_SEGMENT.test(decoded) || LONG_HEX_SEGMENT.test(decoded) || NUMERIC_SEGMENT.test(decoded) || EMAIL_SEGMENT.test(decoded) || OPAQUE_SEGMENT.test(decoded);
+};
+function normalizeHttpRoute(route) {
+  if (typeof route !== "string" || route.length > 2048) {
+    throw new Error("Performance HTTP route must be a string of at most 2048 characters");
+  }
+  if (!route.trim()) {
+    return "/";
+  }
+  const withoutOrigin = route.replace(/^(?:[a-z][a-z0-9+.-]*:)?\/\/[^/]+/i, "");
+  const pathOnly = withoutOrigin.split("?")[0]?.split("#")[0] ?? "/";
+  const normalized = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+  const parts = normalized.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith(":") || segment.startsWith("[") && segment.endsWith("]")) {
+      return segment;
+    }
+    if (isDynamicRouteSegment(segment)) {
+      return ":id";
+    }
+    return segment;
+  });
+  return (parts.length === 0 ? "/" : `/${parts.join("/")}`).slice(0, MAX_NORMALIZED_ROUTE_LENGTH);
+}
+function classifyHttpOutcome(metadata) {
+  if (metadata.aborted) {
+    return "aborted";
+  }
+  if (metadata.timedOut) {
+    return "timeout";
+  }
+  if (typeof metadata.statusCode === "number") {
+    if (metadata.statusCode >= 500) {
+      return "server_error";
+    }
+    if (metadata.statusCode >= 400) {
+      return "client_error";
+    }
+  }
+  return "ok";
+}
+function normalizeHttpMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || isRuntimeProxy(metadata) || Array.isArray(metadata)) {
+    throw new Error("Performance HTTP metadata must be an object");
+  }
+  const readField = (key) => {
+    let descriptor;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(metadata, key);
+    } catch {
+      throw new Error("Performance HTTP metadata must use readable data properties");
+    }
+    return descriptor?.enumerable && "value" in descriptor ? descriptor.value : void 0;
+  };
+  const rawRoute = readField("route");
+  const rawMethod = readField("method");
+  const rawStatusCode = readField("statusCode");
+  const rawRequestSize = readField("requestSize");
+  const rawResponseSize = readField("responseSize");
+  const rawHostKind = readField("hostKind");
+  const rawRuntime = readField("runtime");
+  const rawAborted = readField("aborted");
+  const rawTimedOut = readField("timedOut");
+  const rawOutcome = readField("outcome");
+  if (typeof rawRoute !== "string") throw new Error("Performance HTTP route must be a string");
+  const normalizedRoute = normalizeHttpRoute(rawRoute);
+  if (typeof rawMethod !== "string") {
+    throw new Error("Performance HTTP method must be a string");
+  }
+  const methodCandidate = rawMethod.length <= 32 ? rawMethod.trim().toUpperCase() : "";
+  const normalizedMethod = /^[A-Z][A-Z0-9_-]{0,31}$/.test(methodCandidate) ? methodCandidate : "UNKNOWN";
+  const statusCode = Number.isInteger(rawStatusCode) && rawStatusCode >= 100 && rawStatusCode <= 599 ? rawStatusCode : void 0;
+  const requestSize = Number.isSafeInteger(rawRequestSize) && rawRequestSize >= 0 ? rawRequestSize : void 0;
+  const responseSize = Number.isSafeInteger(rawResponseSize) && rawResponseSize >= 0 ? rawResponseSize : void 0;
+  const normalized = {
+    method: normalizedMethod,
+    route: normalizedRoute,
+    ...statusCode !== void 0 ? { statusCode } : {},
+    ...requestSize !== void 0 ? { requestSize } : {},
+    ...responseSize !== void 0 ? { responseSize } : {},
+    ...typeof rawHostKind === "string" && rawHostKind.length <= 256 ? { hostKind: sanitizePerformanceLabelValue(rawHostKind) } : {},
+    ...typeof rawRuntime === "string" && rawRuntime.length <= 256 ? { runtime: sanitizePerformanceLabelValue(rawRuntime) } : {},
+    ...rawAborted === true ? { aborted: true } : {},
+    ...rawTimedOut === true ? { timedOut: true } : {}
+  };
+  const observedOutcome = normalized.aborted || normalized.timedOut || typeof normalized.statusCode === "number" && normalized.statusCode >= 200 ? classifyHttpOutcome(normalized) : void 0;
+  const outcome = observedOutcome ?? (typeof rawOutcome === "string" && rawOutcome.length <= 16 && HTTP_OUTCOMES.has(rawOutcome) ? rawOutcome : classifyHttpOutcome(normalized));
+  normalized.outcome = outcome;
+  return normalized;
+}
+function buildHttpLabels(metadata, labels) {
+  const normalized = normalizeHttpMetadata(metadata);
+  return {
+    ...labels ?? {},
+    method: normalized.method,
+    route: normalized.route,
+    status_code: String(normalized.statusCode ?? 0),
+    status_class: typeof normalized.statusCode === "number" ? `${Math.floor(normalized.statusCode / 100)}xx` : "unknown",
+    ...normalized.hostKind ? { host_kind: normalized.hostKind } : {},
+    ...normalized.runtime ? { runtime: normalized.runtime } : {},
+    outcome: normalized.outcome ?? "ok"
+  };
+}
+function toPerformanceEventRecord(event, resource) {
+  return {
+    recordedAt: event.end,
+    event,
+    source: event.source,
+    ...event.traceId ? { traceId: event.traceId } : {},
+    ...event.spanId ? { spanId: event.spanId } : {},
+    ...event.http ? { http: event.http } : {},
+    ...event.dbMetadata ? { dbMetadata: event.dbMetadata } : {},
+    ...resource ? { resource } : {}
+  };
+}
+
+// src/performance/core/callback-dispatcher.ts
+var captureCallback = (bundle, key) => {
+  if (isRuntimeProxy(bundle)) return void 0;
+  try {
+    let owner = bundle;
+    for (let depth = 0; owner && depth < 8; depth += 1) {
+      if (isRuntimeProxy(owner)) return void 0;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+      if (descriptor) {
+        if (!("value" in descriptor) || typeof descriptor.value !== "function") return void 0;
+        const callback = descriptor.value;
+        return ((...args) => Reflect.apply(callback, bundle, args));
+      }
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+function createPerformanceCallbackDispatcher(initial) {
+  const callbacks = /* @__PURE__ */ new Set([initial]);
+  let pendingCallbacks = /* @__PURE__ */ new WeakMap();
+  return {
+    emit(name, ...args) {
+      const emissionCallbacks = [...callbacks];
+      const values = emissionCallbacks.length > 1 ? deepFreezePerformanceValue(clonePerformanceValue(args)) : args;
+      for (const bundle of emissionCallbacks) {
+        try {
+          if (pendingCallbacks.get(bundle)?.has(name)) continue;
+          const callback = captureCallback(bundle, name);
+          if (!callback) continue;
+          const pendingNames = pendingCallbacks.get(bundle) ?? /* @__PURE__ */ new Set();
+          pendingNames.add(name);
+          pendingCallbacks.set(bundle, pendingNames);
+          const release = () => {
+            if (pendingCallbacks.get(bundle) !== pendingNames) return;
+            pendingNames.delete(name);
+            if (pendingNames.size === 0) pendingCallbacks.delete(bundle);
+          };
+          let result;
+          try {
+            result = callback(...values);
+          } catch {
+            release();
+            continue;
+          }
+          ignoreRuntimePromiseRejection(result);
+          if (isRuntimePromise(result)) {
+            try {
+              void Reflect.apply(Promise.prototype.then, result, [release, release]);
+            } catch {
+              release();
+            }
+          } else release();
+        } catch {
+        }
+      }
+    },
+    add(bundle) {
+      if (callbacks.has(bundle) || callbacks.size >= 100) return;
+      callbacks.add(bundle);
+    },
+    remove(bundle) {
+      pendingCallbacks.delete(bundle);
+      return callbacks.delete(bundle);
+    },
+    reset() {
+      callbacks.clear();
+      pendingCallbacks = /* @__PURE__ */ new WeakMap();
+      callbacks.add(initial);
+    }
+  };
+}
+var digest = (value) => createHash("sha256").update(value, "utf16le").digest("base64url");
+function fingerprintLabels(labels) {
+  if (!labels || Object.keys(labels).length === 0) return "";
+  const hash = createHash("sha256");
+  const entries = Object.entries(labels).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  for (const [key, value] of entries) {
+    hash.update(`${key.length}:${key}${value.length}:${value}`, "utf16le");
+  }
+  return hash.digest("base64url");
+}
+function createCardinalityGuard(options = {}) {
+  const maxCombinations = options.maxCombinations ?? Number.POSITIVE_INFINITY;
+  const mode = options.mode ?? "drop";
+  const onExceeded = options.onExceeded;
+  const maxMetrics = options.maxMetrics ?? 1e3;
+  const ttlMs = options.ttlMs ?? 60 * 60 * 1e3;
+  const now = options.now ?? Date.now;
+  if (maxCombinations !== Number.POSITIVE_INFINITY && (!Number.isInteger(maxCombinations) || maxCombinations < 0)) {
+    throw new Error("Cardinality maxCombinations must be a non-negative integer or Infinity");
+  }
+  if (maxMetrics !== Number.POSITIVE_INFINITY && (!Number.isInteger(maxMetrics) || maxMetrics <= 0)) {
+    throw new Error("Cardinality maxMetrics must be a positive integer or Infinity");
+  }
+  if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+    throw new Error("Cardinality ttlMs must be a non-negative finite number");
+  }
+  if (mode !== "drop" && mode !== "warn") {
+    throw new Error("Cardinality mode must be drop or warn");
+  }
+  const combinations = /* @__PURE__ */ new Map();
+  const cleanupIntervalMs = ttlMs === 0 ? 0 : Math.min(ttlMs, 6e4);
+  let nextCleanupAt = Number.NEGATIVE_INFINITY;
+  function cleanup(currentTime) {
+    if (cleanupIntervalMs > 0 && currentTime < nextCleanupAt) return;
+    for (const [metricName, entry] of combinations.entries()) {
+      if (currentTime - entry.lastAccessed > ttlMs) {
+        combinations.delete(metricName);
+      }
+    }
+    nextCleanupAt = currentTime + cleanupIntervalMs;
+  }
+  return {
+    check(metricName, labels) {
+      if (!Number.isFinite(maxCombinations)) {
+        return { allowed: true };
+      }
+      let key;
+      try {
+        if (labels) {
+          for (const [, value] of Object.entries(labels)) {
+            if (typeof value !== "string") {
+              return { allowed: false, reason: "invalid-labels" };
+            }
+          }
+        }
+        key = fingerprintLabels(labels);
+      } catch {
+        return { allowed: false, reason: "invalid-labels" };
+      }
+      const currentTime = now();
+      cleanup(currentTime);
+      const metricKey = digest(metricName);
+      let metricCombinations = combinations.get(metricKey);
+      if (!metricCombinations) {
+        if (Number.isFinite(maxMetrics) && combinations.size >= maxMetrics) {
+          if (mode === "warn") {
+            try {
+              onExceeded?.(metricName, "limit-exceeded");
+            } catch {
+            }
+            return { allowed: true, reason: "limit-exceeded" };
+          }
+          return { allowed: false, reason: "limit-exceeded" };
+        }
+        metricCombinations = { labels: /* @__PURE__ */ new Set(), lastAccessed: currentTime };
+        combinations.set(metricKey, metricCombinations);
+      }
+      metricCombinations.lastAccessed = currentTime;
+      combinations.delete(metricKey);
+      combinations.set(metricKey, metricCombinations);
+      if (metricCombinations.labels.has(key)) {
+        return { allowed: true };
+      }
+      if (metricCombinations.labels.size >= maxCombinations) {
+        if (mode === "warn") {
+          if (onExceeded) {
+            try {
+              onExceeded(metricName, "limit-exceeded");
+            } catch {
+            }
+          }
+          return { allowed: true, reason: "limit-exceeded" };
+        }
+        return { allowed: false, reason: "limit-exceeded" };
+      }
+      metricCombinations.labels.add(key);
+      return { allowed: true };
+    },
+    reset() {
+      combinations.clear();
+      nextCleanupAt = Number.NEGATIVE_INFINITY;
+    }
+  };
+}
+
+// src/performance/core/factories/performance-port-measurements.ts
+var safeContextValue = (value) => {
+  if (typeof value === "string") return value.slice(0, 128);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "<invalid>";
+};
+var snapshotResponseStatus = (value) => {
+  if (!value || typeof value !== "object" || isRuntimeProxy(value)) return void 0;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, "status");
+    if (descriptor && "value" in descriptor) {
+      return typeof descriptor.value === "number" ? descriptor.value : void 0;
+    }
+    if (typeof Response === "undefined" || !hasSafeRuntimePrototype(value, Response.prototype)) return void 0;
+    const getter = Object.getOwnPropertyDescriptor(Response.prototype, "status")?.get;
+    const status = typeof getter === "function" ? Reflect.apply(getter, value, []) : void 0;
+    return typeof status === "number" ? status : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var mergeHttpMetadata = (metadata, additions) => {
+  try {
+    return { ...metadata, ...additions };
+  } catch {
+    return { method: "UNKNOWN", route: "/", ...additions };
+  }
+};
+function createMeasurementPortMethods(deps) {
+  const { clock, emitEvent, onError, withFailedDBMetadata } = deps;
+  const invalidLabels = Object.freeze({ "": "" });
+  const captureLabels = (labels) => {
+    try {
+      return snapshotPerformanceLabels(labels);
+    } catch {
+      return invalidLabels;
+    }
+  };
+  const recordRequest = (name, duration, metadata, labels) => {
+    try {
+      const capturedLabels = captureLabels(labels);
+      const http = normalizeHttpMetadata(metadata);
+      const end = clock.now();
+      emitEvent({
+        name,
+        duration,
+        start: end - duration,
+        end,
+        source: "mark",
+        http,
+        labels: buildHttpLabels(http, capturedLabels),
+        ...http.outcome ? { outcome: http.outcome } : {}
+      });
+    } catch (error) {
+      onError(error, { measureName: safeContextValue(name), operation: "record-request" });
+    }
+  };
+  const timedEvent = (name, start, startHr, labels, failed = false) => ({
+    name,
+    duration: nsToMs(clock.nowHr() - startHr),
+    start,
+    end: Math.max(start, clock.now()),
+    source: "mark",
+    ...labels ? { labels } : {},
+    ...failed ? { outcome: "server_error" } : {}
+  });
+  return {
+    measureSync(name, fn, labels) {
+      const start = clock.now();
+      const startHr = clock.nowHr();
+      const capturedLabels = captureLabels(labels);
+      try {
+        const result = fn();
+        emitEvent(timedEvent(name, start, startHr, capturedLabels));
+        return result;
+      } catch (error) {
+        emitEvent(timedEvent(name, start, startHr, capturedLabels, true));
+        throw error;
+      }
+    },
+    measureAsync(name, fn, labels) {
+      const start = clock.now();
+      const startHr = clock.nowHr();
+      const capturedLabels = captureLabels(labels);
+      return Promise.resolve().then(() => fn()).then(
+        (result) => {
+          emitEvent(timedEvent(name, start, startHr, capturedLabels));
+          return result;
+        },
+        (error) => {
+          emitEvent(timedEvent(name, start, startHr, capturedLabels, true));
+          throw error;
+        }
+      );
+    },
+    measureDBQuery(name, fn, metadata, labels) {
+      const start = clock.now();
+      const startHr = clock.nowHr();
+      const capturedLabels = captureLabels(labels);
+      const capturedMetadata = snapshotSafeDBMetadata(metadata);
+      return Promise.resolve().then(() => fn()).then(
+        (result) => {
+          emitEvent(timedEvent(name, start, startHr, capturedLabels), capturedMetadata);
+          return result;
+        },
+        (error) => {
+          emitEvent(
+            timedEvent(name, start, startHr, capturedLabels, true),
+            withFailedDBMetadata(capturedMetadata)
+          );
+          throw error;
+        }
+      );
+    },
+    measureDBQuerySync(name, fn, metadata, labels) {
+      const start = clock.now();
+      const startHr = clock.nowHr();
+      const capturedLabels = captureLabels(labels);
+      const capturedMetadata = snapshotSafeDBMetadata(metadata);
+      try {
+        const result = fn();
+        emitEvent(timedEvent(name, start, startHr, capturedLabels), capturedMetadata);
+        return result;
+      } catch (error) {
+        emitEvent(
+          timedEvent(name, start, startHr, capturedLabels, true),
+          withFailedDBMetadata(capturedMetadata)
+        );
+        throw error;
+      }
+    },
+    record(metric, value, labels) {
+      const end = clock.now();
+      const capturedLabels = captureLabels(labels);
+      emitEvent({
+        name: metric,
+        duration: value,
+        start: end - value,
+        end,
+        source: "mark",
+        ...capturedLabels ? { labels: capturedLabels } : {}
+      });
+    },
+    async measureRequest(name, fn, metadata, labels) {
+      const startHr = clock.nowHr();
+      const capturedLabels = captureLabels(labels);
+      let capturedMetadata;
+      try {
+        capturedMetadata = normalizeHttpMetadata(metadata);
+      } catch {
+        capturedMetadata = { method: "UNKNOWN", route: "/" };
+      }
+      try {
+        const result = await fn();
+        const statusCode = capturedMetadata.statusCode ?? snapshotResponseStatus(result);
+        recordRequest(
+          name,
+          nsToMs(clock.nowHr() - startHr),
+          mergeHttpMetadata(capturedMetadata, statusCode !== void 0 ? { statusCode } : {}),
+          capturedLabels
+        );
+        return result;
+      } catch (error) {
+        let outcome = "server_error";
+        try {
+          if (capturedMetadata.aborted) outcome = "aborted";
+          else if (capturedMetadata.timedOut) outcome = "timeout";
+        } catch {
+        }
+        recordRequest(
+          name,
+          nsToMs(clock.nowHr() - startHr),
+          mergeHttpMetadata(capturedMetadata, { statusCode: void 0, outcome }),
+          capturedLabels
+        );
+        throw error;
+      }
+    },
+    recordRequest
+  };
+}
+
+// src/performance/utils/single-flight-method.ts
+var createSingleFlightMethodCapture = () => {
+  const pendingMethods = /* @__PURE__ */ new WeakMap();
+  return (target, key) => {
+    if (!target || typeof target !== "object" && typeof target !== "function" || isRuntimeProxy(target)) return void 0;
+    try {
+      let owner = target;
+      for (let depth = 0; owner && depth < 16; depth += 1) {
+        if (isRuntimeProxy(owner)) return void 0;
+        const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+        if (descriptor) {
+          if (!("value" in descriptor) || typeof descriptor.value !== "function") return void 0;
+          const method = descriptor.value;
+          return (...args) => {
+            const targetObject = target;
+            const active = pendingMethods.get(targetObject) ?? /* @__PURE__ */ new Set();
+            if (active.has(key)) return void 0;
+            active.add(key);
+            pendingMethods.set(targetObject, active);
+            const release = () => {
+              active.delete(key);
+              if (active.size === 0 && pendingMethods.get(targetObject) === active) {
+                pendingMethods.delete(targetObject);
+              }
+            };
+            let result;
+            try {
+              result = Reflect.apply(method, target, args);
+            } catch (error) {
+              release();
+              throw error;
+            }
+            if (isRuntimePromise(result)) {
+              try {
+                void Reflect.apply(Promise.prototype.then, result, [release, release]);
+              } catch {
+                release();
+              }
+            } else release();
+            return result;
+          };
+        }
+        owner = Object.getPrototypeOf(owner);
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  };
+};
+
+// src/performance/core/tracing-bridge.ts
+var sanitizeSpanValue = (value) => {
+  if (typeof value === "string") return value.length <= 256 ? sanitizePerformanceLabelValue(value) : "[redacted]";
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "boolean") return value;
+  return "[redacted]";
+};
+var SPAN_OPTION_FIELDS = ["labels", "kind", "attributes", "http", "dbMetadata", "createSpan"];
+var snapshotPerformanceSpanOptions = (options) => {
+  if (options === void 0) return void 0;
+  if (!options || typeof options !== "object" || isRuntimeProxy(options) || Array.isArray(options)) return void 0;
+  const snapshot = /* @__PURE__ */ Object.create(null);
+  try {
+    for (const key of SPAN_OPTION_FIELDS) {
+      const descriptor = Object.getOwnPropertyDescriptor(options, key);
+      if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+      if (key === "http") {
+        try {
+          snapshot[key] = normalizeHttpMetadata(descriptor.value);
+        } catch {
+        }
+      } else if (key === "dbMetadata") {
+        const metadata = snapshotSafeDBMetadata(descriptor.value);
+        if (metadata) snapshot[key] = metadata;
+      } else snapshot[key] = descriptor.value;
+    }
+  } catch {
+    return void 0;
+  }
+  return snapshot;
+};
+var sanitizeSpanAttributes = (attributes) => {
+  const sanitized = {};
+  try {
+    const source = attributes ?? {};
+    if (isRuntimeProxy(source)) return {};
+    const prototype = Object.getPrototypeOf(source);
+    if (prototype !== Object.prototype && prototype !== null) return {};
+    let inspected = 0;
+    for (const key in source) {
+      if (inspected >= 32) break;
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (!descriptor?.enumerable) continue;
+      if (!("value" in descriptor)) continue;
+      inspected += 1;
+      if (/^[a-z][a-z0-9_.-]{0,63}$/iu.test(key)) {
+        sanitized[key] = isSensitivePerformanceKey(key) ? "[redacted]" : sanitizeSpanValue(descriptor.value);
+      }
+    }
+  } catch {
+    return {};
+  }
+  return sanitized;
+};
+var sanitizeCorrelationId = (value, length) => typeof value === "string" && value.length === length && /^[0-9a-f]+$/iu.test(value) && !/^0+$/u.test(value) ? value.toLowerCase() : void 0;
+var readCorrelationField = (context, key) => {
+  if (!context || typeof context !== "object" || isRuntimeProxy(context)) return void 0;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(context, key);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var toSpanAttributes = (options, duration, outcome) => ({
+  ...sanitizeSpanAttributes(options?.attributes),
+  ...sanitizeSpanAttributes(options?.labels),
+  "perf.duration_ms": duration,
+  "perf.outcome": outcome,
+  ...options?.http?.route ? { "http.route": sanitizeSpanValue(options.http.route) } : {},
+  ...options?.http?.method ? { "http.method": sanitizeSpanValue(options.http.method) } : {},
+  ...typeof options?.http?.statusCode === "number" ? { "http.status_code": sanitizeSpanValue(options.http.statusCode) } : {},
+  ...options?.dbMetadata?.collection ? { "db.collection": sanitizeSpanValue(options.dbMetadata.collection) } : {},
+  ...options?.dbMetadata?.table ? { "db.table": sanitizeSpanValue(options.dbMetadata.table) } : {},
+  ...options?.dbMetadata?.operation ? { "db.operation": sanitizeSpanValue(options.dbMetadata.operation) } : {},
+  ...options?.dbMetadata?.queryHash ? { "db.query_hash": sanitizeSpanValue(options.dbMetadata.queryHash) } : {}
+});
+function createPerformanceTracingBridge(tracer) {
+  const captureMethod = createSingleFlightMethodCapture();
+  const captureSpanMethod = createSingleFlightMethodCapture();
+  const getActiveSpan = captureMethod(tracer, "getActiveSpan");
+  const readCurrentTraceId = captureMethod(tracer, "currentTraceId");
+  const inSpan = captureMethod(tracer, "inSpan");
+  return {
+    getCorrelation() {
+      let context;
+      try {
+        const activeSpan = getActiveSpan?.();
+        context = captureSpanMethod(activeSpan, "getContext")?.();
+      } catch {
+      }
+      let currentTraceId;
+      try {
+        currentTraceId = readCurrentTraceId?.();
+      } catch {
+      }
+      const traceId = sanitizeCorrelationId(currentTraceId, 32) ?? sanitizeCorrelationId(readCorrelationField(context, "traceId"), 32);
+      const spanId = sanitizeCorrelationId(readCorrelationField(context, "spanId"), 16);
+      return {
+        ...traceId ? { traceId } : {},
+        ...spanId ? { spanId } : {}
+      };
+    },
+    async withSpan(name, options, fn) {
+      if (!tracer) {
+        return await fn(void 0);
+      }
+      const capturedOptions = snapshotPerformanceSpanOptions(options);
+      const createSpan = capturedOptions?.createSpan === true;
+      if (createSpan) {
+        if (!inSpan) return await fn(void 0);
+        let spanOptions;
+        try {
+          spanOptions = {
+            ...capturedOptions?.kind ? { kind: capturedOptions.kind } : {},
+            ...capturedOptions?.attributes ? { attributes: sanitizeSpanAttributes(capturedOptions.attributes) } : {}
+          };
+        } catch {
+          return await fn(void 0);
+        }
+        let invoked = false;
+        let callbackPromise;
+        const invokeOnce = (span) => {
+          callbackPromise ??= Promise.resolve().then(async () => await fn(span));
+          return callbackPromise;
+        };
+        try {
+          const tracerOperation = inSpan(name, async (span) => {
+            invoked = true;
+            try {
+              return await invokeOnce(span);
+            } catch {
+              return void 0;
+            }
+          }, { ...spanOptions });
+          ignoreRuntimePromiseRejection(tracerOperation);
+          await Promise.resolve();
+          if (!invoked) return await invokeOnce(void 0);
+          return await callbackPromise;
+        } catch {
+          if (!invoked) return await invokeOnce(void 0);
+          return await callbackPromise;
+        }
+      }
+      let activeSpan;
+      try {
+        activeSpan = getActiveSpan?.();
+      } catch {
+      }
+      return await fn(activeSpan);
+    },
+    annotate(span, options, duration, outcome) {
+      if (!span) {
+        return;
+      }
+      try {
+        const setAttribute = captureSpanMethod(span, "setAttribute");
+        const addEvent = captureSpanMethod(span, "addEvent");
+        const setStatus = captureSpanMethod(span, "setStatus");
+        const capturedOptions = snapshotPerformanceSpanOptions(options);
+        for (const [key, value] of Object.entries(toSpanAttributes(capturedOptions, duration, outcome))) {
+          setAttribute?.(key, value);
+        }
+        addEvent?.("performance.measurement", {
+          ...sanitizeSpanAttributes(capturedOptions?.labels),
+          duration_ms: duration,
+          outcome
+        });
+        setStatus?.({ code: outcome === "ok" ? "ok" : "error" });
+      } catch {
+      }
+    },
+    recordError(span, _error) {
+      if (!span) {
+        return;
+      }
+      try {
+        const recordException = captureSpanMethod(span, "recordException");
+        const setStatus = captureSpanMethod(span, "setStatus");
+        const message = "Performance measured operation failed";
+        recordException?.(new Error(message));
+        setStatus?.({ code: "error", description: message });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/performance/core/base-handler.ts
+var RESOURCE_VALUE_LABELS = /* @__PURE__ */ new Set(["user", "system", "utilization", "rss", "heapUsed", "heapTotal", "external"]);
+var snapshotEventLabels = (labels, options = {}) => {
+  if (!labels) return void 0;
+  const entries = Object.entries(snapshotPerformanceLabels(labels) ?? {});
+  const snapshot = {};
+  for (const [key, value] of entries) {
+    if (!/^[a-z_][a-z0-9_.-]{0,63}$/i.test(key) || typeof value !== "string" || value.length > 256) {
+      throw new Error("Performance event labels exceed safe key/value limits");
+    }
+    if (options.preserveHttpRoute && key === "route") {
+      if (hasControlCharacters(value)) throw new Error("Performance HTTP routes cannot contain control characters");
+      snapshot[key] = value;
+    } else if (options.preserveResourceValues && RESOURCE_VALUE_LABELS.has(key)) {
+      const numeric = Number(value);
+      if (!Number.isFinite(numeric) || numeric < 0) throw new Error("Performance resource labels must be non-negative finite numbers");
+      snapshot[key] = value;
+    } else {
+      snapshot[key] = isSensitivePerformanceKey(key) ? "[redacted]" : sanitizePerformanceLabelValue(value);
+    }
+  }
+  return snapshot;
+};
+var VALID_EVENT_SOURCES = /* @__PURE__ */ new Set(["runtime", "mark", "feature"]);
+var VALID_EVENT_OUTCOMES = /* @__PURE__ */ new Set(["ok", "client_error", "server_error", "timeout", "aborted"]);
+function createBasePerformanceHandler(options) {
+  const clock = createHighResClock({ clock: options.clock });
+  const dispatcher = createPerformanceCallbackDispatcher(options.callbacks ?? {});
+  const cardinality = createCardinalityGuard({
+    maxCombinations: options.cardinalityLimit,
+    mode: options.cardinalityMode,
+    now: clock.now,
+    onExceeded: (name, reason) => dispatcher.emit("onDimensionExplosion", name, reason)
+  });
+  const tracing = createPerformanceTracingBridge(options.tracer);
+  const onError = createPerformanceOnError(options.errors, { operation: "measure" });
+  let extensions = {};
+  let state = "running";
+  let droppedEvents = 0;
+  let activeMeasurements = 0;
+  let activeBarrier;
+  let releaseActiveBarrier;
+  let monitorsStopped = false;
+  let finalizationFailureCode;
+  const beginMeasurement = () => {
+    if (state !== "running") return void 0;
+    activeMeasurements += 1;
+    dispatcher.emit("onSelfMetric", "_performance_active_measurements", activeMeasurements);
+    return () => {
+      activeMeasurements -= 1;
+      dispatcher.emit("onSelfMetric", "_performance_active_measurements", activeMeasurements);
+      if (activeMeasurements === 0) {
+        releaseActiveBarrier?.();
+        releaseActiveBarrier = void 0;
+        activeBarrier = void 0;
+      }
+    };
+  };
+  const waitForActive = async () => {
+    if (activeMeasurements === 0) return;
+    activeBarrier ??= new Promise((resolve) => {
+      releaseActiveBarrier = resolve;
+    });
+    let timer;
+    try {
+      await Promise.race([
+        activeBarrier,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("PERFORMANCE_DRAIN_TIMEOUT")), 5e3);
+        })
+      ]);
+    } finally {
+      try {
+        if (timer) clearTimeout(timer);
+      } catch {
+      }
+    }
+  };
+  const withFailedDBMetadata = (metadata) => {
+    try {
+      return { ...metadata ?? {}, success: false, failureCode: "query_failed" };
+    } catch {
+      return { success: false, failureCode: "query_failed" };
+    }
+  };
+  const emitEvent = (event, metadata) => {
+    if (state === "closed") return;
+    let enriched;
+    let eventName = "<invalid>";
+    try {
+      const rawName = event.name;
+      const validName = typeof rawName === "string" && rawName.length <= 128 && Boolean(rawName.trim()) && !hasControlCharacters(rawName);
+      eventName = validName ? sanitizePerformanceEventName(rawName) : "<invalid>";
+      if (!validName || !Number.isFinite(event.duration) || event.duration < 0 || !Number.isFinite(event.start) || !Number.isFinite(event.end) || event.end < event.start || !VALID_EVENT_SOURCES.has(event.source) || event.outcome !== void 0 && !VALID_EVENT_OUTCOMES.has(event.outcome)) {
+        throw new Error("Invalid performance event");
+      }
+      const correlation = tracing.getCorrelation();
+      const resourceSnapshot = isResourceSnapshotEvent(event.source, eventName);
+      const http = event.http ? normalizeHttpMetadata(event.http) : void 0;
+      const labels = snapshotEventLabels(
+        http ? buildHttpLabels(http, event.labels) : event.labels,
+        { preserveHttpRoute: Boolean(http), preserveResourceValues: resourceSnapshot }
+      );
+      const resolvedOutcome = event.outcome ?? http?.outcome;
+      enriched = {
+        ...event,
+        name: eventName,
+        ...labels ? { labels } : {},
+        ...http ? { http } : {},
+        ...resolvedOutcome ? { outcome: resolvedOutcome } : {},
+        ...metadata ? { dbMetadata: snapshotSafeDBMetadata(metadata) } : event.dbMetadata ? { dbMetadata: snapshotSafeDBMetadata(event.dbMetadata) } : {},
+        ...event.traceId ?? correlation.traceId ? { traceId: event.traceId ?? correlation.traceId } : {},
+        ...event.spanId ?? correlation.spanId ? { spanId: event.spanId ?? correlation.spanId } : {}
+      };
+      const cardinalityLabels = resourceSnapshot ? void 0 : enriched.labels;
+      const check = cardinality.check(enriched.name, cardinalityLabels);
+      if (!check.allowed) {
+        droppedEvents += 1;
+        dispatcher.emit("onSelfMetric", "_performance_dropped_total", 1, { reason: check.reason ?? "cardinality" });
+        dispatcher.emit("onDimensionDrop", enriched.name, check.reason ?? "limit-exceeded");
+        return;
+      }
+      if (check.reason) {
+        enriched = {
+          ...enriched,
+          name: "cardinality_overflow",
+          labels: { reason: check.reason }
+        };
+      }
+    } catch (error) {
+      droppedEvents += 1;
+      dispatcher.emit("onSelfMetric", "_performance_dropped_total", 1, { reason: "invalid_event" });
+      onError(error, { eventName });
+      return;
+    }
+    enriched = deepFreezePerformanceValue(enriched);
+    dispatcher.emit("onSelfMetric", "_performance_recorded_total", 1, { source: enriched.source });
+    try {
+      extensions.onAcceptedEvent?.(enriched);
+    } catch (error) {
+      onError(error, { eventName: enriched.name, operation: "accepted-event-extension" });
+    }
+    dispatcher.emit("onPerfEvent", enriched);
+  };
+  const measurements = createMeasurementPortMethods({
+    clock,
+    emitEvent,
+    onError,
+    withFailedDBMetadata
+  });
+  let monitoring;
+  try {
+    monitoring = options.createRuntimeMonitoring?.({
+      clock,
+      onPerfEvent: emitEvent,
+      onSaturationAlert: (alert) => dispatcher.emit("onSaturationAlert", alert),
+      ...options.errors ? { errors: options.errors } : {},
+      enableEventLoopMonitor: options.enableEventLoopMonitor,
+      enableGCMonitor: options.enableGCMonitor,
+      enableResourceMonitor: options.enableResourceMonitor
+    });
+    extensions = options.createExtensions?.(dispatcher, clock) ?? {};
+  } catch (error) {
+    try {
+      monitoring?.stop();
+    } catch {
+    }
+    throw error;
+  }
+  let shutdownPromise;
+  const port = {
+    record(name, value, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return;
+      try {
+        measurements.record(name, value, labels);
+      } finally {
+        finish();
+      }
+    },
+    async measureAsync(name, fn, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return await fn();
+      try {
+        return await measurements.measureAsync(name, fn, labels);
+      } finally {
+        finish();
+      }
+    },
+    measureSync(name, fn, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return fn();
+      try {
+        return measurements.measureSync(name, fn, labels);
+      } finally {
+        finish();
+      }
+    },
+    async measureDBQuery(name, fn, metadata, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return await fn();
+      try {
+        return await measurements.measureDBQuery(name, fn, metadata, labels);
+      } finally {
+        finish();
+      }
+    },
+    measureDBQuerySync(name, fn, metadata, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return fn();
+      try {
+        return measurements.measureDBQuerySync(name, fn, metadata, labels);
+      } finally {
+        finish();
+      }
+    },
+    async measureRequest(name, fn, metadata, labels) {
+      const finish = beginMeasurement();
+      if (!finish) return await fn();
+      try {
+        return await measurements.measureRequest(name, fn, metadata, labels);
+      } finally {
+        finish();
+      }
+    },
+    async measureSpan(name, fn, spanOptions) {
+      const finish = beginMeasurement();
+      if (!finish) return await fn();
+      try {
+        const capturedSpanOptions = snapshotPerformanceSpanOptions(spanOptions);
+        const traceSpanName = typeof name === "string" && name.length <= 128 && name.trim() && !hasControlCharacters(name) ? sanitizePerformanceEventName(name) : "performance.measurement";
+        return await tracing.withSpan(traceSpanName, capturedSpanOptions, async (span) => {
+          let eventLabels;
+          let dbMetadata;
+          let httpMetadata;
+          try {
+            eventLabels = snapshotPerformanceLabels(capturedSpanOptions?.labels);
+            dbMetadata = snapshotSafeDBMetadata(capturedSpanOptions?.dbMetadata);
+            httpMetadata = capturedSpanOptions?.http ? normalizeHttpMetadata(capturedSpanOptions.http) : void 0;
+          } catch {
+          }
+          const started = clock.now();
+          const startedHr = clock.nowHr();
+          try {
+            const result = await fn();
+            const duration = Number(clock.nowHr() - startedHr) / 1e6;
+            const end = Math.max(started, clock.now());
+            tracing.annotate(span, capturedSpanOptions, duration, "ok");
+            emitEvent({
+              name,
+              duration,
+              start: started,
+              end,
+              source: "mark",
+              ...httpMetadata ? { http: httpMetadata } : {},
+              ...httpMetadata?.outcome ? { outcome: httpMetadata.outcome } : {},
+              labels: { ...eventLabels ?? {}, instrumentation: "span" }
+            }, dbMetadata);
+            return result;
+          } catch (error) {
+            const duration = Number(clock.nowHr() - startedHr) / 1e6;
+            const end = Math.max(started, clock.now());
+            const failureOutcome = httpMetadata?.aborted ? "aborted" : httpMetadata?.timedOut ? "timeout" : "server_error";
+            tracing.annotate(span, capturedSpanOptions, duration, "error");
+            tracing.recordError(span, error);
+            emitEvent({
+              name,
+              duration,
+              start: started,
+              end,
+              source: "mark",
+              outcome: failureOutcome,
+              ...httpMetadata ? { http: {
+                ...httpMetadata,
+                statusCode: void 0,
+                outcome: failureOutcome
+              } } : {},
+              labels: { ...eventLabels ?? {}, instrumentation: "span" }
+            }, dbMetadata ? withFailedDBMetadata(dbMetadata) : void 0);
+            throw error;
+          }
+        });
+      } finally {
+        finish();
+      }
+    },
+    getBudgetStatus(name) {
+      if (typeof name !== "string" || name.length > 128) return void 0;
+      try {
+        const status = extensions.getBudgetStatus?.(name);
+        return status ? Object.freeze({ ...status }) : void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    async flush() {
+      if (state === "closed") return;
+      if (state === "draining" && shutdownPromise) return await shutdownPromise;
+      try {
+        await extensions.flush?.();
+      } catch (error) {
+        dispatcher.emit("onSelfMetric", "_performance_finalization_failures_total", 1, { operation: "flush" });
+        throw error;
+      }
+    },
+    async shutdown() {
+      if (state === "closed") return;
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          state = "draining";
+          if (!monitorsStopped) {
+            monitorsStopped = true;
+            try {
+              monitoring?.stop();
+            } catch (error) {
+              onError(error, { operation: "runtime-monitor.stop" });
+            }
+          }
+          await waitForActive();
+          await extensions.shutdown?.();
+          state = "closed";
+          finalizationFailureCode = void 0;
+        })();
+      }
+      try {
+        await shutdownPromise;
+      } catch (error) {
+        finalizationFailureCode = "PERFORMANCE_FINALIZATION_FAILURE";
+        dispatcher.emit("onSelfMetric", "_performance_finalization_failures_total", 1, { operation: "shutdown" });
+        shutdownPromise = void 0;
+        throw error;
+      }
+    },
+    getStatus() {
+      let status;
+      try {
+        status = extensions.getExportStatus?.();
+      } catch {
+        status = {
+          queueSize: 0,
+          droppedTotal: 0,
+          retriedTotal: 0,
+          sinkState: "unhealthy",
+          lastFailureCode: "PERFORMANCE_STATUS_FAILURE"
+        };
+      }
+      return Object.freeze({
+        state,
+        activeMeasurements,
+        queueSize: status?.queueSize ?? 0,
+        droppedTotal: droppedEvents + (status?.droppedTotal ?? 0),
+        retriedTotal: status?.retriedTotal ?? 0,
+        sinkState: state === "closed" ? "closed" : finalizationFailureCode ? "unhealthy" : status?.sinkState ?? "healthy",
+        ...finalizationFailureCode ?? status?.lastFailureCode ? { lastFailureCode: finalizationFailureCode ?? status?.lastFailureCode } : {}
+      });
+    }
+  };
+  registerPerformanceDispatcher(port, dispatcher);
+  return port;
+}
+
+// src/performance/utils/lifecycle-cleanup.ts
+var captureLifecycleMethod = (lifecycle, key) => {
+  if (isRuntimeProxy(lifecycle)) return void 0;
+  try {
+    let owner = lifecycle;
+    for (let depth = 0; owner && depth < 16; depth += 1) {
+      if (isRuntimeProxy(owner)) return void 0;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+      if (descriptor) {
+        if (!("value" in descriptor) || typeof descriptor.value !== "function") return void 0;
+        const method = descriptor.value;
+        return ((...args) => Reflect.apply(method, lifecycle, args));
+      }
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+function registerPerformanceLifecycleCleanup(lifecycle, handler) {
+  if (!lifecycle) return;
+  const registerFlushHook = captureLifecycleMethod(lifecycle, "registerFlushHook");
+  const registerShutdownHook = captureLifecycleMethod(lifecycle, "registerShutdownHook");
+  let disposers = [];
+  const addDisposer = (value) => {
+    if (typeof value === "function") disposers.push(value);
+    else ignoreRuntimePromiseRejection(value);
+  };
+  try {
+    if (registerFlushHook && handler.flush) {
+      addDisposer(registerFlushHook(
+        "performance-export",
+        async () => await handler.flush?.()
+      ));
+    }
+    if (registerShutdownHook && handler.shutdown) {
+      addDisposer(registerShutdownHook(
+        "runtime-monitors",
+        async () => await handler.shutdown?.(),
+        { name: "performance-cleanup", priority: 30 }
+      ));
+    }
+  } catch (error) {
+    const cleanupErrors = [];
+    for (const disposer of disposers.reverse()) {
+      try {
+        ignoreRuntimePromiseRejection(disposer());
+      } catch (cleanupError) {
+        cleanupErrors.push(cleanupError);
+      }
+    }
+    disposers = [];
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError([error, ...cleanupErrors], "Performance lifecycle registration rollback failed");
+    }
+    throw error;
+  }
+  if (!handler.shutdown || disposers.length === 0) return;
+  const shutdown = handler.shutdown.bind(handler);
+  handler.shutdown = async () => {
+    await shutdown();
+    const activeDisposers = disposers;
+    disposers = [];
+    for (const disposer of activeDisposers.reverse()) {
+      try {
+        ignoreRuntimePromiseRejection(disposer());
+      } catch {
+      }
+    }
+  };
+}
+async function failPerformanceSetup(handler, setupError) {
+  try {
+    await handler.shutdown?.();
+  } catch (cleanupError) {
+    throw new AggregateError(
+      [setupError, cleanupError],
+      "Performance setup and cleanup failed"
+    );
+  }
+  throw setupError;
+}
+
+export { createBasePerformanceHandler, failPerformanceSetup, registerPerformanceLifecycleCleanup, toPerformanceEventRecord };
+//# sourceMappingURL=chunk-ZAXGEDZW.js.map
+//# sourceMappingURL=chunk-ZAXGEDZW.js.map