@ooopsstudio/performance 0.9.0

package/dist/event-export-manager-DEB64LWZ.js

@@ -0,0 +1,632 @@
+import { deepFreezePerformanceValue } from './chunk-J6KBSLYO.js';
+import { MAX_PERFORMANCE_TIMER_MS, withPerformanceExportTimeout, serializePerformanceEventRecord, MAX_PERFORMANCE_EXPORT_BATCH_BYTES, getPerformanceExportErrorMetadata, sleep, createPerformanceExportError, MAX_PERFORMANCE_EXPORT_BATCH_COUNT } from './chunk-3GMKPRQP.js';
+import { isRuntimeProxy, ignoreRuntimePromiseRejection, isRuntimePromise } from './chunk-RL2752FW.js';
+import { normalizeError } from '@ooopsstudio/core/utils/error/normalize-error';
+
+// src/performance/core/event-export-lifecycle.ts
+function createEventExporterLifecycleOperations() {
+  const completed = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    run(name, hookName, hook) {
+      const key = `${hookName}:${name}`;
+      if (completed.has(key)) return Promise.resolve();
+      const existing = pending.get(key);
+      if (existing) return existing;
+      const operation = Promise.resolve().then(async () => await hook());
+      pending.set(key, operation);
+      void operation.then(
+        () => {
+          completed.add(key);
+          pending.delete(key);
+        },
+        () => pending.delete(key)
+      );
+      return operation;
+    }
+  };
+}
+
+// src/performance/core/event-export-manager.ts
+var MAX_EXPORT_OPERATION_TIMEOUT_MS = 5e3;
+var MAX_EXPORT_RETRY_DELAY_MS = 5e3;
+var MAX_EXPORT_DELIVERY_BUDGET_MS = 3e4;
+var KNOWN_EXPORT_FAILURE_CODE = /^(?:performance_export_timeout|http_(?:rate_limited|server_error|client_error|unexpected_status)|fetch_(?:aborted|failed)|invalid_fetch_response|event_serialization_failed)$/;
+var DROPPED_TOTAL_METRIC = "_performance_dropped_total";
+var QUEUE_SIZE_METRIC = "_performance_export_queue_size";
+var captureExporterMethod = (target, key) => {
+  if (isRuntimeProxy(target) || typeof target !== "object" && typeof target !== "function" || target === null) 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 result = Reflect.apply(method, target, args);
+          if (result !== void 0 && !isRuntimePromise(result)) throw createPerformanceExportError("", {
+            retryable: false,
+            code: "invalid_exporter_result"
+          });
+          return result;
+        };
+      }
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+var hasExporterProperty = (target, key) => {
+  if (isRuntimeProxy(target) || typeof target !== "object" && typeof target !== "function" || target === null) return false;
+  try {
+    let owner = target;
+    for (let depth = 0; owner && depth < 16; depth += 1) {
+      if (isRuntimeProxy(owner)) return true;
+      if (Object.getOwnPropertyDescriptor(owner, key)) return true;
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return true;
+  }
+  return false;
+};
+var captureErrorsReport = (errors) => {
+  if (!errors || typeof errors !== "object" && typeof errors !== "function" || isRuntimeProxy(errors)) return void 0;
+  try {
+    let owner = errors;
+    for (let depth = 0; owner && depth < 16; depth += 1) {
+      if (isRuntimeProxy(owner)) return void 0;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, "report");
+      if (descriptor) {
+        if (!("value" in descriptor) || typeof descriptor.value !== "function") return void 0;
+        const report = descriptor.value;
+        return (...args) => Reflect.apply(report, errors, args);
+      }
+      owner = Object.getPrototypeOf(owner);
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+var captureExporter = (name, exporter) => {
+  const exportBatch = captureExporterMethod(exporter, "export");
+  const flush = captureExporterMethod(exporter, "flush");
+  const shutdown = captureExporterMethod(exporter, "shutdown");
+  if (!exportBatch) throw new Error(`Performance event exporter "${name}" must provide a data-method export function`);
+  if (hasExporterProperty(exporter, "flush") && !flush) {
+    throw new Error(`Performance event exporter "${name}" flush must be a data-method function`);
+  }
+  if (hasExporterProperty(exporter, "shutdown") && !shutdown) {
+    throw new Error(`Performance event exporter "${name}" shutdown must be a data-method function`);
+  }
+  return Object.freeze({
+    export: exportBatch,
+    ...flush ? { flush } : {},
+    ...shutdown ? { shutdown } : {}
+  });
+};
+function createEventExportManager(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("Performance event export options must be an object");
+  }
+  const {
+    exporters: configuredExporters,
+    maxBufferCount,
+    maxBufferBytes,
+    flushIntervalMs,
+    retryAttempts,
+    retryBaseDelayMs,
+    operationTimeoutMs = 5e3,
+    errors,
+    observe
+  } = options;
+  if (isRuntimeProxy(configuredExporters) || !Array.isArray(configuredExporters)) {
+    throw new Error("Performance event exporters must be an array");
+  }
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(configuredExporters, "length");
+  const configuredExporterCount = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : -1;
+  if (!Number.isSafeInteger(configuredExporterCount) || configuredExporterCount > 2) {
+    throw new Error("Performance event export supports at most two exporters");
+  }
+  const configuredEntries = [];
+  for (let index = 0; index < configuredExporterCount; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(configuredExporters, String(index));
+    if (!descriptor || !("value" in descriptor)) {
+      throw new Error("Performance event exporters must use data properties");
+    }
+    const configured = descriptor.value;
+    if (!configured || typeof configured !== "object" || isRuntimeProxy(configured)) {
+      throw new Error("Performance event exporters must be valid objects");
+    }
+    let name;
+    let exporter;
+    try {
+      const nameDescriptor = Object.getOwnPropertyDescriptor(configured, "name");
+      const exporterDescriptor = Object.getOwnPropertyDescriptor(configured, "exporter");
+      if (!nameDescriptor || !("value" in nameDescriptor) || !exporterDescriptor || !("value" in exporterDescriptor)) {
+        throw new TypeError();
+      }
+      name = nameDescriptor.value;
+      exporter = exporterDescriptor.value;
+    } catch {
+      throw new Error("Performance event exporters must use data properties");
+    }
+    configuredEntries.push({ name, exporter });
+  }
+  if (!Number.isInteger(maxBufferCount) || maxBufferCount <= 0 || maxBufferCount > 1e5) {
+    throw new Error("Performance event export maxBufferCount must be between 1 and 100000");
+  }
+  if (!Number.isSafeInteger(maxBufferBytes) || maxBufferBytes <= 0 || maxBufferBytes > 100 * 1024 * 1024) {
+    throw new Error("Performance event export maxBufferBytes must be between 1 and 104857600");
+  }
+  if (!Number.isSafeInteger(flushIntervalMs) || flushIntervalMs < 0 || flushIntervalMs > MAX_PERFORMANCE_TIMER_MS) {
+    throw new Error(`Performance flushIntervalMs must be between 0 and ${MAX_PERFORMANCE_TIMER_MS}`);
+  }
+  if (!Number.isInteger(retryAttempts) || retryAttempts < 0 || retryAttempts > 10) {
+    throw new Error("Performance event export retryAttempts must be between 0 and 10");
+  }
+  if (!Number.isSafeInteger(retryBaseDelayMs) || retryBaseDelayMs < 0 || retryBaseDelayMs > MAX_EXPORT_RETRY_DELAY_MS) {
+    throw new Error(`Performance retryBaseDelayMs must be between 0 and ${MAX_EXPORT_RETRY_DELAY_MS}`);
+  }
+  if (!Number.isSafeInteger(operationTimeoutMs) || operationTimeoutMs <= 0 || operationTimeoutMs > MAX_EXPORT_OPERATION_TIMEOUT_MS) {
+    throw new Error(`Performance operationTimeoutMs must be between 1 and ${MAX_EXPORT_OPERATION_TIMEOUT_MS}`);
+  }
+  if (operationTimeoutMs * (retryAttempts + 1) + retryBaseDelayMs * (retryAttempts * (retryAttempts + 1) / 2) > MAX_EXPORT_DELIVERY_BUDGET_MS) {
+    throw new Error(`Performance event export retry policy must fit within ${MAX_EXPORT_DELIVERY_BUDGET_MS}ms`);
+  }
+  const exporterNames = /* @__PURE__ */ new Set();
+  const exporters = [];
+  for (const configured of configuredEntries) {
+    const { name } = configured;
+    if (typeof name !== "string" || name.length > 64 || !/^[a-z][a-z0-9_.-]{0,63}$/i.test(name) || exporterNames.has(name)) {
+      throw new Error("Performance event exporter names must be unique safe identifiers");
+    }
+    exporters.push({ name, exporter: captureExporter(name, configured.exporter) });
+    exporterNames.add(name);
+  }
+  const logicalQueue = [];
+  let logicalQueueBytes = 0;
+  let partiallyCommittedRecords = 0;
+  let nextSequence = 0;
+  const exporterHealth = /* @__PURE__ */ new Map();
+  const terminalExporters = /* @__PURE__ */ new Set();
+  const completedExporterLifecycles = /* @__PURE__ */ new Set();
+  const pendingDeliveries = /* @__PURE__ */ new Map();
+  const pendingFlushHooks = /* @__PURE__ */ new Map();
+  const exportersNeedingFlush = /* @__PURE__ */ new Set();
+  const lifecycleOperations = createEventExporterLifecycleOperations();
+  for (const { name } of exporters) {
+    exporterHealth.set(name, { isHealthy: true, failures: 0 });
+  }
+  let droppedEvents = 0;
+  let retriedTotal = 0;
+  let activeRetries = 0;
+  let lastFailureCode;
+  let stopped = false;
+  let closing = false;
+  let flushPromise = null;
+  let requestedFlushGeneration = 0;
+  let completedFlushGeneration = 0;
+  let requestedExporterHooks = false;
+  let shutdownPromise = null;
+  let timer;
+  const errorsReport = captureErrorsReport(errors);
+  let pendingErrorReport;
+  let pendingObservation;
+  const reportError = (context) => {
+    if (pendingErrorReport) return;
+    pendingErrorReport = true;
+    try {
+      const result = errorsReport?.(normalizeError(new Error("performance_export_failed")), context);
+      ignoreRuntimePromiseRejection(result);
+      if (isRuntimePromise(result)) {
+        const reportPromise = result;
+        pendingErrorReport = reportPromise;
+        const release = () => {
+          if (pendingErrorReport === reportPromise) pendingErrorReport = void 0;
+        };
+        void Reflect.apply(Promise.prototype.then, reportPromise, [
+          release,
+          release
+        ]);
+      } else pendingErrorReport = void 0;
+    } catch {
+    }
+  };
+  const emit = (name, value, labels) => {
+    if (pendingObservation) return;
+    pendingObservation = true;
+    try {
+      const result = observe?.(name, value, labels);
+      ignoreRuntimePromiseRejection(result);
+      if (isRuntimePromise(result)) {
+        const observation = result;
+        pendingObservation = observation;
+        const release = () => {
+          if (pendingObservation === observation) pendingObservation = void 0;
+        };
+        try {
+          void Reflect.apply(Promise.prototype.then, observation, [release, release]);
+        } catch {
+          release();
+        }
+      } else pendingObservation = void 0;
+    } catch {
+    }
+  };
+  const setExporterFailure = (name, error) => {
+    const previous = exporterHealth.get(name) ?? { failures: 0 };
+    const safeError = getPerformanceExportErrorMetadata(error)?.code ?? "performance_export_failed";
+    lastFailureCode = KNOWN_EXPORT_FAILURE_CODE.test(safeError) ? safeError.toUpperCase() : "PERFORMANCE_EXPORT_FAILURE";
+    exporterHealth.set(name, {
+      isHealthy: false,
+      failures: previous.failures + 1
+    });
+    emit("_performance_export_failures_total", 1);
+    reportError({ stage: "performance", operation: "event_export", exporter: name });
+  };
+  const setExporterSuccess = (name) => {
+    const previous = exporterHealth.get(name) ?? { failures: 0 };
+    exporterHealth.set(name, {
+      isHealthy: true,
+      failures: previous.failures
+    });
+    if ([...exporterHealth.values()].every(({ isHealthy }) => isHealthy)) lastFailureCode = void 0;
+  };
+  const getActiveExporterNames = () => exporters.map(({ name }) => name).filter((name) => !terminalExporters.has(name));
+  const countPending = (name, through) => logicalQueue.filter((item) => item.id <= through && item.pending.has(name)).length;
+  const pruneCommitted = () => {
+    let committedCount = 0;
+    let committedBytes = 0;
+    while (logicalQueue[committedCount]?.pending.size === 0) {
+      committedBytes += logicalQueue[committedCount].bytes;
+      committedCount += 1;
+    }
+    if (committedCount > 0) {
+      logicalQueue.splice(0, committedCount);
+      logicalQueueBytes -= committedBytes;
+    }
+  };
+  const removePendingDestination = (item, name) => {
+    if (!item.pending.delete(name)) return false;
+    if (item.pending.size > 0 && !item.partial) {
+      item.partial = true;
+      partiallyCommittedRecords += 1;
+    } else if (item.pending.size === 0 && item.partial) {
+      item.partial = false;
+      partiallyCommittedRecords -= 1;
+    }
+    return true;
+  };
+  const abandonDestination = (name) => {
+    let terminalDrops = 0;
+    for (const item of logicalQueue) {
+      if (removePendingDestination(item, name)) terminalDrops += 1;
+    }
+    pruneCommitted();
+    droppedEvents += terminalDrops;
+    if (terminalDrops > 0) emit(DROPPED_TOTAL_METRIC, terminalDrops, { reason: "terminal_exporter_error" });
+    emit(QUEUE_SIZE_METRIC, logicalQueue.length);
+  };
+  const terminateDestination = (name, error) => {
+    if (terminalExporters.has(name)) return;
+    terminalExporters.add(name);
+    setExporterFailure(name, error);
+    abandonDestination(name);
+  };
+  const releasePartiallyCommittedRecord = (activeDestinationCount) => {
+    if (partiallyCommittedRecords === 0 || activeDestinationCount < 2) return false;
+    const index = logicalQueue.findIndex((item) => item.partial && item.pending.size < activeDestinationCount);
+    if (index < 0) return false;
+    const releasedBytes = logicalQueue[index].bytes;
+    logicalQueue[index].partial = false;
+    partiallyCommittedRecords -= 1;
+    logicalQueue.splice(index, 1);
+    logicalQueueBytes -= releasedBytes;
+    droppedEvents += 1;
+    emit(DROPPED_TOTAL_METRIC, 1, { reason: "partial_fanout_backpressure" });
+    emit(QUEUE_SIZE_METRIC, logicalQueue.length);
+    return true;
+  };
+  const deliverBatch = (name, exporter, through) => {
+    const existing = pendingDeliveries.get(name);
+    if (existing) return existing;
+    const items = [];
+    let batchBytes = 0;
+    for (const item of logicalQueue) {
+      if (item.id > through) break;
+      if (!item.pending.has(name)) continue;
+      if (items.length >= MAX_PERFORMANCE_EXPORT_BATCH_COUNT || batchBytes + item.bytes > MAX_PERFORMANCE_EXPORT_BATCH_BYTES) break;
+      items.push(item);
+      batchBytes += item.bytes;
+    }
+    const attemptBatch = deepFreezePerformanceValue(
+      items.map((item) => JSON.parse(item.serialized))
+    );
+    const operation = Promise.resolve().then(async () => await exporter.export(attemptBatch)).then(() => {
+      setExporterSuccess(name);
+      if (exporter.flush) exportersNeedingFlush.add(name);
+      for (const item of items) removePendingDestination(item, name);
+      pruneCommitted();
+      emit(QUEUE_SIZE_METRIC, logicalQueue.length);
+      if (pendingDeliveries.get(name) === operation) pendingDeliveries.delete(name);
+    });
+    pendingDeliveries.set(name, operation);
+    void operation.catch((error) => {
+      if (pendingDeliveries.get(name) === operation) pendingDeliveries.delete(name);
+      const metadata = getPerformanceExportErrorMetadata(error);
+      if (metadata?.retryable === false) terminateDestination(name, error);
+    });
+    return operation;
+  };
+  const runExporterFlush = (name, exporter) => {
+    const existing = pendingFlushHooks.get(name);
+    if (existing) return existing;
+    const operation = Promise.resolve().then(async () => await exporter.flush?.());
+    pendingFlushHooks.set(name, operation);
+    void operation.then(
+      () => pendingFlushHooks.delete(name),
+      () => pendingFlushHooks.delete(name)
+    );
+    return operation;
+  };
+  const runFlushCycle = async (flushExporterHooks) => {
+    if (stopped || exporters.length === 0) {
+      return;
+    }
+    const failures = [];
+    await Promise.all(exporters.map(async ({ name, exporter }) => {
+      if (terminalExporters.has(name)) {
+        return;
+      }
+      const boundary = logicalQueue.at(-1)?.id ?? -1;
+      let remainingBatchCount = countPending(name, boundary);
+      let deliverySucceeded = remainingBatchCount === 0;
+      let failedAttempts = 0;
+      while (remainingBatchCount > 0) {
+        if (terminalExporters.has(name)) {
+          failures.push(new Error("Exporter failed"));
+          break;
+        }
+        remainingBatchCount = countPending(name, boundary);
+        if (remainingBatchCount === 0) {
+          deliverySucceeded = true;
+          break;
+        }
+        let delivery;
+        try {
+          delivery = deliverBatch(name, exporter, boundary);
+          await withPerformanceExportTimeout(
+            delivery,
+            operationTimeoutMs,
+            `Exporter "${name}"`
+          );
+          remainingBatchCount = countPending(name, boundary);
+          deliverySucceeded = remainingBatchCount === 0;
+          failedAttempts = 0;
+        } catch (error) {
+          const errorMetadata = getPerformanceExportErrorMetadata(error);
+          if (errorMetadata?.code !== "performance_export_timeout" && delivery && pendingDeliveries.get(name) === delivery) {
+            pendingDeliveries.delete(name);
+          }
+          const retryable = errorMetadata?.retryable ?? true;
+          if (!retryable || failedAttempts >= retryAttempts) {
+            if (retryable) setExporterFailure(name, error);
+            else terminateDestination(name, error);
+            failures.push(error);
+            break;
+          }
+          failedAttempts += 1;
+          retriedTotal += 1;
+          emit("_performance_export_retries_total", 1);
+          activeRetries += 1;
+          try {
+            await sleep(retryBaseDelayMs * failedAttempts);
+          } finally {
+            activeRetries -= 1;
+          }
+        }
+      }
+      if (!deliverySucceeded || !flushExporterHooks || !exporter.flush || !exportersNeedingFlush.has(name)) return;
+      for (let attempt = 0; attempt <= retryAttempts; attempt += 1) {
+        try {
+          await withPerformanceExportTimeout(
+            runExporterFlush(name, exporter),
+            operationTimeoutMs,
+            `Exporter "${name}" flush`
+          );
+          setExporterSuccess(name);
+          exportersNeedingFlush.delete(name);
+          break;
+        } catch (error) {
+          if (attempt >= retryAttempts) {
+            setExporterFailure(name, error);
+            failures.push(error);
+            break;
+          }
+          retriedTotal += 1;
+          emit("_performance_export_retries_total", 1);
+          activeRetries += 1;
+          try {
+            await sleep(retryBaseDelayMs * (attempt + 1));
+          } finally {
+            activeRetries -= 1;
+          }
+        }
+      }
+    })).then(() => {
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "Performance event export flush failed");
+      }
+    });
+  };
+  const flush = async (flushExporterHooks = true) => {
+    if (stopped || exporters.length === 0) return;
+    requestedFlushGeneration = Math.max(
+      requestedFlushGeneration,
+      completedFlushGeneration + (flushPromise ? 2 : 1)
+    );
+    requestedExporterHooks ||= flushExporterHooks;
+    if (!flushPromise) {
+      flushPromise = (async () => {
+        while (completedFlushGeneration < requestedFlushGeneration) {
+          const targetGeneration = requestedFlushGeneration;
+          const runExporterHooks = requestedExporterHooks;
+          requestedExporterHooks = false;
+          await runFlushCycle(runExporterHooks);
+          completedFlushGeneration = targetGeneration;
+        }
+      })().finally(() => {
+        flushPromise = null;
+      });
+    }
+    return flushPromise;
+  };
+  if (exporters.length > 0 && flushIntervalMs > 0) {
+    timer = setInterval(() => {
+      void flush().catch(() => reportError({
+        stage: "performance",
+        operation: "event_export_timer_flush"
+      }));
+    }, flushIntervalMs);
+    try {
+      timer.unref?.();
+    } catch {
+    }
+  }
+  return {
+    enqueue(record) {
+      if (stopped || closing || exporters.length === 0) {
+        return;
+      }
+      const activeNames = getActiveExporterNames();
+      if (activeNames.length === 0) {
+        droppedEvents += 1;
+        emit(DROPPED_TOTAL_METRIC, 1, { reason: "terminal_exporter_unavailable" });
+        return;
+      }
+      const saturatedReason = logicalQueue.length >= maxBufferCount ? "count_limit" : logicalQueueBytes >= maxBufferBytes ? "byte_limit" : void 0;
+      if (saturatedReason && (partiallyCommittedRecords === 0 || activeNames.length < 2)) {
+        droppedEvents += 1;
+        emit(DROPPED_TOTAL_METRIC, 1, { reason: saturatedReason });
+        return;
+      }
+      const snapshot = serializePerformanceEventRecord(record);
+      if (snapshot === null || snapshot.bytes > MAX_PERFORMANCE_EXPORT_BATCH_BYTES) {
+        droppedEvents += 1;
+        emit(DROPPED_TOTAL_METRIC, 1, {
+          reason: snapshot ? "record_size_limit" : "serialization_error"
+        });
+        if (!snapshot) reportError({
+          stage: "performance",
+          operation: "event_export_enqueue"
+        });
+        return;
+      }
+      let dropReason = logicalQueue.length >= maxBufferCount ? "count_limit" : logicalQueueBytes + snapshot.bytes > maxBufferBytes ? "byte_limit" : void 0;
+      while (dropReason && releasePartiallyCommittedRecord(activeNames.length)) {
+        dropReason = logicalQueue.length >= maxBufferCount ? "count_limit" : logicalQueueBytes + snapshot.bytes > maxBufferBytes ? "byte_limit" : void 0;
+      }
+      if (dropReason) {
+        droppedEvents += 1;
+        emit(DROPPED_TOTAL_METRIC, 1, { reason: dropReason });
+        return;
+      }
+      logicalQueue.push({
+        serialized: snapshot.serialized,
+        bytes: snapshot.bytes,
+        pending: new Set(activeNames),
+        partial: false,
+        id: nextSequence++
+      });
+      logicalQueueBytes += snapshot.bytes;
+      emit(QUEUE_SIZE_METRIC, logicalQueue.length);
+    },
+    flush,
+    async shutdown() {
+      if (shutdownPromise) {
+        return shutdownPromise;
+      }
+      shutdownPromise = (async () => {
+        closing = true;
+        if (timer !== void 0) {
+          const activeTimer = timer;
+          timer = void 0;
+          try {
+            clearInterval(activeTimer);
+          } catch {
+          }
+        }
+        const failures = [];
+        try {
+          await flush(false);
+        } catch (error) {
+          failures.push(error);
+        }
+        const undelivered = logicalQueue.length;
+        if (undelivered > 0) {
+          failures.push(new Error(`Performance event exporter shutdown left ${undelivered} event(s) undelivered`));
+          throw new AggregateError(failures, "Performance event exporter shutdown failed");
+        }
+        await Promise.all(exporters.map(async ({ name, exporter }) => {
+          if (completedExporterLifecycles.has(name)) return;
+          let failed = false;
+          if (exporter.flush) {
+            try {
+              await withPerformanceExportTimeout(
+                lifecycleOperations.run(name, "flush", () => runExporterFlush(name, exporter)),
+                operationTimeoutMs,
+                "Exporter flush"
+              );
+            } catch (error) {
+              failed = true;
+              failures.push(error);
+            }
+          }
+          let shutdownCompleted = false;
+          if (exporter.shutdown) {
+            try {
+              await withPerformanceExportTimeout(
+                lifecycleOperations.run(name, "shutdown", () => exporter.shutdown?.()),
+                operationTimeoutMs,
+                "Exporter shutdown"
+              );
+              shutdownCompleted = true;
+            } catch (error) {
+              failed = true;
+              failures.push(error);
+            }
+          }
+          if (!failed || shutdownCompleted) completedExporterLifecycles.add(name);
+        }));
+        if (failures.length > 0) {
+          throw new AggregateError(failures, "Performance event exporter shutdown failed");
+        }
+        stopped = true;
+      })().catch((error) => {
+        shutdownPromise = null;
+        throw error;
+      });
+      return shutdownPromise;
+    },
+    getStatus() {
+      const unhealthy = terminalExporters.size > 0 || [...exporterHealth.values()].some(({ isHealthy }) => !isHealthy);
+      return Object.freeze({
+        queueSize: logicalQueue.length,
+        droppedTotal: droppedEvents,
+        retriedTotal,
+        sinkState: stopped ? "closed" : unhealthy ? "unhealthy" : activeRetries > 0 ? "degraded" : "healthy",
+        ...lastFailureCode ? { lastFailureCode } : {}
+      });
+    }
+  };
+}
+
+export { createEventExportManager };
+//# sourceMappingURL=event-export-manager-DEB64LWZ.js.map
+//# sourceMappingURL=event-export-manager-DEB64LWZ.js.map