apitally 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/activation.cjs

@@ -1,393 +1,311 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var activation_exports = {};
-__export(activation_exports, {
-  activate: () => activate,
-  activationFactories: () => activationFactories,
-  configure: () => configure,
-  flushTelemetry: () => flushTelemetry,
-  getActivationHandles: () => getActivationHandles,
-  isActivated: () => isActivated,
-  registerStartupEventInfo: () => registerStartupEventInfo,
-  resetActivation: () => resetActivation,
-  shutdown: () => shutdown
-});
-module.exports = __toCommonJS(activation_exports);
-var import_node_worker_threads = require("node:worker_threads");
-var import_api = require("@opentelemetry/api");
-var import_instrumentation_undici = require("@opentelemetry/instrumentation-undici");
-var import_sdk_logs = require("@opentelemetry/sdk-logs");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-var import_config = require('./config.cjs');
-var import_exportWorker = require('./exportWorker.cjs');
-var import_logCapture = require('./logCapture.cjs');
-var import_logger = require('./logger.cjs');
-var import_logRecordExporter = require('./logRecordExporter.cjs');
-var import_logRecordProcessor = require('./logRecordProcessor.cjs');
-var import_metrics = require('./metrics.cjs');
-var import_packageVersion = require('./packageVersion.cjs');
-var import_providers = require('./providers.cjs');
-var import_redaction = require('./redaction.cjs');
-var import_sentry = require('./sentry.cjs');
-var import_serverErrors = require('./serverErrors.cjs');
-var import_spanExporter = require('./spanExporter.cjs');
-var import_spanProcessor = require('./spanProcessor.cjs');
-var import_spool = require('./spool.cjs');
-var import_startup = require('./startup.cjs');
-var import_validationErrors = require('./validationErrors.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_logger = require("./logger.cjs");
+const require_config = require("./config.cjs");
+const require_packageVersion = require("./packageVersion.cjs");
+const require_exportWorker = require("./exportWorker.cjs");
+const require_logCapture = require("./logCapture.cjs");
+const require_logRecordExporter = require("./logRecordExporter.cjs");
+const require_logRecordProcessor = require("./logRecordProcessor.cjs");
+const require_providers = require("./providers.cjs");
+const require_metrics = require("./metrics.cjs");
+const require_redaction = require("./redaction.cjs");
+const require_sentry = require("./sentry.cjs");
+const require_serverErrors = require("./serverErrors.cjs");
+const require_spanProcessor = require("./spanProcessor.cjs");
+const require_spanExporter = require("./spanExporter.cjs");
+const require_spool = require("./spool.cjs");
+const require_startup = require("./startup.cjs");
+const require_validationErrors = require("./validationErrors.cjs");
+let node_worker_threads = require("node:worker_threads");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_instrumentation_undici = require("@opentelemetry/instrumentation-undici");
+let _opentelemetry_sdk_logs = require("@opentelemetry/sdk-logs");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+//#region src/activation.ts
 const BATCH_SCHEDULE_DELAY_MILLIS = 1e3;
 const BATCH_EXPORT_TIMEOUT_MILLIS = 3e4;
 const BATCH_MAX_QUEUE_SIZE = 2048;
 const BATCH_MAX_EXPORT_BATCH_SIZE = 512;
 const BATCH_MAX_EXPORT_BATCH_SIZE_WITH_BODY_CAPTURE = 32;
 const SIGNAL_FLUSH_TIMEOUT_MILLIS = 5e3;
-const ACTIVATION_STATE_KEY = /* @__PURE__ */ Symbol.for("apitally.activation");
+const ACTIVATION_STATE_KEY = Symbol.for("apitally.activation");
 function configure(options = {}) {
-  const config = (0, import_config.setConfig)(options);
-  if (!config.disabled && process.env.OTEL_SEMCONV_STABILITY_OPT_IN === void 0) {
-    process.env.OTEL_SEMCONV_STABILITY_OPT_IN = "http/dup";
-  }
-  (0, import_spanProcessor.setServerSpanActivationCallback)(activate);
-  return config;
+	const config = require_config.setConfig(options);
+	if (!config.disabled && process.env.OTEL_SEMCONV_STABILITY_OPT_IN === void 0) process.env.OTEL_SEMCONV_STABILITY_OPT_IN = "http/dup";
+	require_spanProcessor.setServerSpanActivationCallback(activate);
+	return config;
 }
 function registerStartupEventInfo(info) {
-  const activationState = getActivationState();
-  activationState.startupEventInfo ??= info;
+	const activationState = getActivationState();
+	activationState.startupEventInfo ??= info;
 }
-function activate(triggeringSpan) {
-  const activationState = getActivationState();
-  if (activationState.activationAttempted) {
-    return;
-  }
-  activationState.activationAttempted = true;
-  if (shouldSkipActivation()) {
-    return;
-  }
-  try {
-    const handles = startPipelines(activationState.startupEventInfo, triggeringSpan);
-    activationState.handles = handles;
-    activationState.runShutdown = () => drainAndStop(handles);
-    installBeforeExitHook(activationState);
-    installSignalHooks(activationState);
-  } catch (error) {
-    (0, import_logger.logError)(`Apitally activation failed: ${String(error)}`);
-  }
+function activate() {
+	const activationState = getActivationState();
+	if (activationState.activationAttempted) return;
+	activationState.activationAttempted = true;
+	if (shouldSkipActivation()) return;
+	try {
+		const handles = startPipelines(activationState.startupEventInfo);
+		activationState.handles = handles;
+		activationState.runShutdown = () => drainAndStop(handles);
+		installBeforeExitHook(activationState);
+		installSignalHooks(activationState);
+	} catch (error) {
+		require_logger.logError(`Apitally activation failed: ${String(error)}`);
+	}
 }
 function isActivated() {
-  return getActivationState().handles !== void 0;
+	return getActivationState().handles !== void 0;
 }
 function getActivationHandles() {
-  return getActivationState().handles;
+	return getActivationState().handles;
 }
 async function flushTelemetry() {
-  try {
-    await getActivationState().handles?.worker.runCycle();
-  } catch (error) {
-    (0, import_logger.logDebug)(`Error flushing telemetry: ${String(error)}`);
-  }
+	try {
+		await getActivationState().handles?.worker.runCycle();
+	} catch (error) {
+		require_logger.logDebug(`Error flushing telemetry: ${String(error)}`);
+	}
 }
 function shutdown() {
-  const activationState = getActivationState();
-  const handles = activationState.handles;
-  const runShutdown = activationState.runShutdown;
-  if (!handles || !runShutdown) {
-    return Promise.resolve();
-  }
-  if (!activationState.shutdownPromise) {
-    removeLifecycleHooks(activationState);
-    const signalDrainPromise = activationState.signalDrainPromise;
-    activationState.shutdownPromise = (signalDrainPromise ? signalDrainPromise.then(() => handles.worker.waitForIdle()) : Promise.resolve()).then(runShutdown);
-  }
-  return activationState.shutdownPromise;
+	const activationState = getActivationState();
+	const handles = activationState.handles;
+	const runShutdown = activationState.runShutdown;
+	if (!handles || !runShutdown) return Promise.resolve();
+	if (!activationState.shutdownPromise) {
+		removeLifecycleHooks(activationState);
+		const signalDrainPromise = activationState.signalDrainPromise;
+		activationState.shutdownPromise = (signalDrainPromise ? signalDrainPromise.then(() => handles.worker.waitForIdle()) : Promise.resolve()).then(runShutdown);
+	}
+	return activationState.shutdownPromise;
 }
 const activationFactories = {
-  createSpool: () => new import_spool.Spool(),
-  createExportWorker: (options) => new import_exportWorker.ExportWorker(options)
+	createSpool: () => new require_spool.Spool(),
+	createExportWorker: (options) => new require_exportWorker.ExportWorker(options)
 };
 const defaultFactories = { ...activationFactories };
 async function resetActivation() {
-  Object.assign(activationFactories, defaultFactories);
-  const holder = globalThis;
-  const activationState = holder[ACTIVATION_STATE_KEY];
-  delete holder[ACTIVATION_STATE_KEY];
-  hasWarnedAboutVersionSkew = false;
-  (0, import_validationErrors.resetValidationErrors)();
-  (0, import_serverErrors.resetServerErrors)();
-  if (!activationState) {
-    return;
-  }
-  removeLifecycleHooks(activationState);
-  const handles = activationState.handles;
-  if (!handles) {
-    return;
-  }
-  handles.undiciInstrumentation?.disable();
-  await handles.worker.stop();
-  await handles.spanPipeline.shutdown();
-  await handles.loggerProvider.shutdown();
-  await handles.spool.clear();
+	Object.assign(activationFactories, defaultFactories);
+	const holder = globalThis;
+	const activationState = holder[ACTIVATION_STATE_KEY];
+	delete holder[ACTIVATION_STATE_KEY];
+	hasWarnedAboutVersionSkew = false;
+	require_validationErrors.resetValidationErrors();
+	require_serverErrors.resetServerErrors();
+	if (!activationState) return;
+	removeLifecycleHooks(activationState);
+	const handles = activationState.handles;
+	if (!handles) return;
+	handles.undiciInstrumentation?.disable();
+	await handles.worker.stop();
+	await handles.spanPipeline.shutdown();
+	await handles.loggerProvider.shutdown();
+	await handles.spool.clear();
 }
 let hasWarnedAboutVersionSkew = false;
 function emitErrorEvents(loggerProvider) {
-  const logger = loggerProvider.getLogger("apitally");
-  const events = [
-    [import_validationErrors.VALIDATION_ERROR_EVENT_NAME, (0, import_validationErrors.drainValidationErrors)()],
-    [import_serverErrors.SERVER_ERROR_EVENT_NAME, (0, import_serverErrors.drainServerErrors)()]
-  ];
-  for (const [eventName, bodies] of events) {
-    for (const body of bodies) {
-      logger.emit({ timestamp: Date.now(), context: import_api.ROOT_CONTEXT, eventName, body });
-    }
-  }
+	const logger = loggerProvider.getLogger("apitally");
+	const events = [[require_validationErrors.VALIDATION_ERROR_EVENT_NAME, require_validationErrors.drainValidationErrors()], [require_serverErrors.SERVER_ERROR_EVENT_NAME, require_serverErrors.drainServerErrors()]];
+	for (const [eventName, bodies] of events) for (const body of bodies) logger.emit({
+		timestamp: Date.now(),
+		context: _opentelemetry_api.ROOT_CONTEXT,
+		eventName,
+		body
+	});
 }
 function getActivationState() {
-  const holder = globalThis;
-  const existing = holder[ACTIVATION_STATE_KEY];
-  if (existing) {
-    if (!hasWarnedAboutVersionSkew && existing.sdkVersion !== (0, import_packageVersion.getDistroVersion)()) {
-      hasWarnedAboutVersionSkew = true;
-      (0, import_logger.logWarning)(
-        `Two copies of the apitally package with different versions (${existing.sdkVersion} and ${(0, import_packageVersion.getDistroVersion)()}) are loaded in this process; version ${existing.sdkVersion} stays active. To resolve this, deduplicate the apitally installation.`
-      );
-    }
-    return existing;
-  }
-  const activationState = {
-    sdkVersion: (0, import_packageVersion.getDistroVersion)(),
-    activationAttempted: false
-  };
-  holder[ACTIVATION_STATE_KEY] = activationState;
-  return activationState;
+	const holder = globalThis;
+	const existing = holder[ACTIVATION_STATE_KEY];
+	if (existing) {
+		if (!hasWarnedAboutVersionSkew && existing.sdkVersion !== require_packageVersion.getDistroVersion()) {
+			hasWarnedAboutVersionSkew = true;
+			require_logger.logWarning(`Two copies of the apitally package with different versions (${existing.sdkVersion} and ${require_packageVersion.getDistroVersion()}) are loaded in this process; version ${existing.sdkVersion} stays active. To resolve this, deduplicate the apitally installation.`);
+		}
+		return existing;
+	}
+	const activationState = {
+		sdkVersion: require_packageVersion.getDistroVersion(),
+		activationAttempted: false
+	};
+	holder[ACTIVATION_STATE_KEY] = activationState;
+	return activationState;
 }
 function shouldSkipActivation() {
-  return Boolean(process.env.JEST_WORKER_ID) || Boolean(process.env.VITEST) || process.env.NODE_ENV === "test" || // The emergency kill switch overrides an explicit disabled: false option.
-  (0, import_config.isApitallyDisabledViaEnv)() || (0, import_config.getConfig)().disabled;
+	return Boolean(process.env.JEST_WORKER_ID) || Boolean(process.env.VITEST) || process.env.NODE_ENV === "test" || require_config.getConfig().disabled;
 }
-function startPipelines(startupEventInfo, triggeringSpan) {
-  const config = (0, import_config.getConfig)();
-  let hasUserProvider = (0, import_spanProcessor.isApitallySpanProcessorDeclared)();
-  const { env, resource } = (0, import_providers.resolveEnvAndCreateResource)(hasUserProvider, triggeringSpan?.resource);
-  const instanceId = resource.attributes["service.instance.id"];
-  const spool = activationFactories.createSpool();
-  const spanExporter = new import_spanExporter.ApitallySpanExporter({
-    redaction: new import_redaction.Redaction(),
-    env,
-    instanceId,
-    spool,
-    maskRequestBody: config.maskRequestBody,
-    maskResponseBody: config.maskResponseBody
-  });
-  const batchSpanProcessor = new import_sdk_trace_base.BatchSpanProcessor(spanExporter, {
-    scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,
-    exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,
-    maxQueueSize: BATCH_MAX_QUEUE_SIZE,
-    maxExportBatchSize: config.captureRequestBody || config.captureResponseBody ? BATCH_MAX_EXPORT_BATCH_SIZE_WITH_BODY_CAPTURE : BATCH_MAX_EXPORT_BATCH_SIZE
-  });
-  const spanPipeline = new import_spanProcessor.SpanPipeline(batchSpanProcessor);
-  let tracerProvider;
-  if (!hasUserProvider) {
-    tracerProvider = (0, import_providers.setupTracerProvider)(resource, [spanPipeline]);
-    if (!tracerProvider) {
-      hasUserProvider = true;
-      (0, import_logger.logWarning)(
-        "Apitally could not register its OpenTelemetry tracer provider because another provider is already registered. Only metrics and the startup event are sent to Apitally until you add ApitallySpanProcessor (exported by the apitally package) to your tracer provider's spanProcessors constructor option or the NodeSDK spanProcessors option."
-      );
-    }
-  }
-  (0, import_spanProcessor.setActiveSpanPipeline)(spanPipeline);
-  const batchLogProcessor = new import_sdk_logs.BatchLogRecordProcessor({
-    exporter: new import_logRecordExporter.ApitallyLogRecordExporter(spool),
-    scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,
-    exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,
-    maxQueueSize: BATCH_MAX_QUEUE_SIZE,
-    maxExportBatchSize: BATCH_MAX_EXPORT_BATCH_SIZE
-  });
-  const logRecordProcessor = new import_logRecordProcessor.ApitallyLogRecordProcessor(
-    batchLogProcessor,
-    spanPipeline,
-    config.maskLogRecord
-  );
-  const loggerProvider = (0, import_providers.createLoggerProvider)(resource, [logRecordProcessor]);
-  const metricsPipeline = new import_metrics.MetricsPipeline(resource, spool);
-  spanPipeline.metricsRecorder = (record) => metricsPipeline.recordFromRequest(record);
-  const worker = activationFactories.createExportWorker({
-    spool,
-    otlpEndpoint: config.otlpEndpoint,
-    writeToken: config.writeToken,
-    env
-  });
-  worker.flushCallbacks.push(
-    () => metricsPipeline.collectAndExport(),
-    () => batchSpanProcessor.forceFlush(),
-    () => emitErrorEvents(loggerProvider),
-    () => batchLogProcessor.forceFlush()
-  );
-  if (config.captureLogs) {
-    (0, import_logCapture.installConsoleCapture)(loggerProvider);
-    (0, import_logCapture.installNestLoggerCapture)(loggerProvider);
-    (0, import_logCapture.installWinstonCapture)(loggerProvider);
-    (0, import_logCapture.installPinoCapture)(loggerProvider);
-  }
-  (0, import_sentry.installSentryEventIdRecording)();
-  let undiciInstrumentation;
-  if (!hasUserProvider) {
-    undiciInstrumentation = createUndiciInstrumentation(config.otlpEndpoint);
-  }
-  worker.start();
-  if (startupEventInfo) {
-    (0, import_startup.emitStartupEvent)(loggerProvider, startupEventInfo);
-  }
-  return {
-    spanPipeline,
-    tracerProvider,
-    loggerProvider,
-    metricsPipeline,
-    spool,
-    worker,
-    undiciInstrumentation
-  };
+function startPipelines(startupEventInfo) {
+	const config = require_config.getConfig();
+	let hasUserProvider = require_spanProcessor.isApitallySpanProcessorDeclared();
+	const { env, resource } = require_providers.resolveEnvAndCreateResource();
+	const instanceId = resource.attributes["service.instance.id"];
+	const spool = activationFactories.createSpool();
+	const spanExporter = new require_spanExporter.ApitallySpanExporter({
+		redaction: new require_redaction.Redaction(),
+		env,
+		instanceId,
+		spool,
+		maskRequestBody: config.maskRequestBody,
+		maskResponseBody: config.maskResponseBody
+	});
+	const batchSpanProcessor = new _opentelemetry_sdk_trace_base.BatchSpanProcessor(spanExporter, {
+		scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,
+		exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,
+		maxQueueSize: BATCH_MAX_QUEUE_SIZE,
+		maxExportBatchSize: config.captureRequestBody || config.captureResponseBody ? BATCH_MAX_EXPORT_BATCH_SIZE_WITH_BODY_CAPTURE : BATCH_MAX_EXPORT_BATCH_SIZE
+	});
+	const spanPipeline = new require_spanProcessor.SpanPipeline(batchSpanProcessor, () => spanExporter.forceFlush());
+	let tracerProvider;
+	if (!hasUserProvider) {
+		tracerProvider = require_providers.setupTracerProvider(resource, [spanPipeline]);
+		if (!tracerProvider) {
+			hasUserProvider = true;
+			require_logger.logWarning("Apitally could not register its OpenTelemetry tracer provider because another provider is already registered. Only metrics and the startup event are sent to Apitally until you add ApitallySpanProcessor (exported by the apitally package) to your tracer provider's spanProcessors constructor option or the NodeSDK spanProcessors option.");
+		}
+	}
+	require_spanProcessor.setActiveSpanPipeline(spanPipeline);
+	const batchLogProcessor = new _opentelemetry_sdk_logs.BatchLogRecordProcessor({
+		exporter: new require_logRecordExporter.ApitallyLogRecordExporter(spool),
+		scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,
+		exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,
+		maxQueueSize: BATCH_MAX_QUEUE_SIZE,
+		maxExportBatchSize: BATCH_MAX_EXPORT_BATCH_SIZE
+	});
+	const logRecordProcessor = new require_logRecordProcessor.ApitallyLogRecordProcessor(batchLogProcessor, spanPipeline, config.maskLogRecord);
+	const loggerProvider = require_providers.createLoggerProvider(resource, [logRecordProcessor]);
+	const metricsPipeline = new require_metrics.MetricsPipeline(resource, spool);
+	spanPipeline.metricsRecorder = (record) => metricsPipeline.recordFromRequest(record);
+	const worker = activationFactories.createExportWorker({
+		spool,
+		otlpEndpoint: config.otlpEndpoint,
+		writeToken: config.writeToken,
+		env
+	});
+	worker.flushCallbacks.push(() => metricsPipeline.collectAndExport(), () => spanPipeline.forceFlush(), () => emitErrorEvents(loggerProvider), () => batchLogProcessor.forceFlush());
+	if (config.captureLogs) {
+		require_logCapture.installConsoleCapture(loggerProvider);
+		require_logCapture.installNestLoggerCapture(loggerProvider);
+		require_logCapture.installWinstonCapture(loggerProvider);
+		require_logCapture.installPinoCapture(loggerProvider);
+	}
+	require_sentry.installSentryEventIdRecording();
+	let undiciInstrumentation;
+	if (!hasUserProvider) undiciInstrumentation = createUndiciInstrumentation(config.otlpEndpoint);
+	worker.start();
+	if (startupEventInfo) require_startup.emitStartupEvent(loggerProvider, startupEventInfo);
+	return {
+		spanPipeline,
+		tracerProvider,
+		loggerProvider,
+		metricsPipeline,
+		spool,
+		worker,
+		undiciInstrumentation
+	};
 }
 function createUndiciInstrumentation(otlpEndpoint) {
-  const endpointOrigin = new URL(otlpEndpoint).origin;
-  return new import_instrumentation_undici.UndiciInstrumentation({
-    ignoreRequestHook: (request) => {
-      try {
-        return new URL(String(request.origin)).origin === endpointOrigin;
-      } catch {
-        return false;
-      }
-    }
-  });
+	const endpointOrigin = new URL(otlpEndpoint).origin;
+	return new _opentelemetry_instrumentation_undici.UndiciInstrumentation({ ignoreRequestHook: (request) => {
+		try {
+			return new URL(String(request.origin)).origin === endpointOrigin;
+		} catch {
+			return false;
+		}
+	} });
 }
 async function drainAndStop(handles) {
-  try {
-    await handles.spanPipeline.shutdown();
-    await handles.worker.finalDrain();
-    await handles.loggerProvider.shutdown();
-    await handles.worker.stop();
-  } catch (error) {
-    (0, import_logger.logWarning)(`Error draining telemetry on shutdown: ${String(error)}`);
-  }
+	try {
+		await handles.spanPipeline.shutdown();
+		await handles.worker.finalDrain();
+		await handles.loggerProvider.shutdown();
+		await handles.worker.stop();
+	} catch (error) {
+		require_logger.logWarning(`Error draining telemetry on shutdown: ${String(error)}`);
+	}
 }
 function installSignalHooks(activationState) {
-  if (process.platform === "win32" || !import_node_worker_threads.isMainThread) {
-    return;
-  }
-  let listeners;
-  listeners = {
-    SIGTERM: () => handleTerminationSignal(activationState, listeners, "SIGTERM"),
-    SIGINT: () => handleTerminationSignal(activationState, listeners, "SIGINT")
-  };
-  activationState.signalListeners = listeners;
-  try {
-    process.prependOnceListener("SIGTERM", listeners.SIGTERM);
-    process.prependOnceListener("SIGINT", listeners.SIGINT);
-  } catch (error) {
-    removeSignalHooks(activationState, listeners);
-    (0, import_logger.logWarning)(`Unable to install Apitally signal handlers: ${String(error)}`);
-  }
+	if (process.platform === "win32" || !node_worker_threads.isMainThread) return;
+	let listeners = {
+		SIGTERM: () => handleTerminationSignal(activationState, listeners, "SIGTERM"),
+		SIGINT: () => handleTerminationSignal(activationState, listeners, "SIGINT")
+	};
+	activationState.signalListeners = listeners;
+	try {
+		process.prependOnceListener("SIGTERM", listeners.SIGTERM);
+		process.prependOnceListener("SIGINT", listeners.SIGINT);
+	} catch (error) {
+		removeSignalHooks(activationState, listeners);
+		require_logger.logWarning(`Unable to install Apitally signal handlers: ${String(error)}`);
+	}
 }
 function handleTerminationSignal(activationState, listeners, signal) {
-  const hasApplicationListener = process.listeners(signal).some((listener) => listener !== listeners[signal]);
-  removeSignalHooks(activationState, listeners);
-  const drainPromise = flushAfterTerminationSignal(activationState, signal, hasApplicationListener);
-  activationState.signalDrainPromise = drainPromise;
-  void drainPromise.catch((error) => {
-    (0, import_logger.logDebug)(`Error flushing telemetry on ${signal}: ${String(error)}`);
-  });
+	const hasApplicationListener = process.listeners(signal).some((listener) => listener !== listeners[signal]);
+	removeSignalHooks(activationState, listeners);
+	const drainPromise = flushAfterTerminationSignal(activationState, signal, hasApplicationListener);
+	activationState.signalDrainPromise = drainPromise;
+	drainPromise.catch((error) => {
+		require_logger.logDebug(`Error flushing telemetry on ${signal}: ${String(error)}`);
+	});
 }
 async function flushAfterTerminationSignal(activationState, signal, hasApplicationListener) {
-  const handles = activationState.handles;
-  if (!handles) {
-    return;
-  }
-  try {
-    if (activationState.shutdownPromise) {
-      await waitForSignalDeadline(activationState.shutdownPromise);
-    } else {
-      await handles.worker.finalDrain(SIGNAL_FLUSH_TIMEOUT_MILLIS);
-    }
-  } catch (error) {
-    (0, import_logger.logDebug)(`Error flushing telemetry on ${signal}: ${String(error)}`);
-  }
-  if (hasApplicationListener || process.listeners(signal).length > 0) {
-    return;
-  }
-  const exitCode = signal === "SIGTERM" ? 143 : 130;
-  if (process.platform === "linux" && process.pid === 1) {
-    process.exit(exitCode);
-  }
-  try {
-    process.kill(process.pid, signal);
-  } catch {
-    process.exit(exitCode);
-  }
+	const handles = activationState.handles;
+	if (!handles) return;
+	try {
+		if (activationState.shutdownPromise) await waitForSignalDeadline(activationState.shutdownPromise);
+		else await handles.worker.finalDrain(SIGNAL_FLUSH_TIMEOUT_MILLIS);
+	} catch (error) {
+		require_logger.logDebug(`Error flushing telemetry on ${signal}: ${String(error)}`);
+	}
+	if (hasApplicationListener || process.listeners(signal).length > 0) return;
+	const exitCode = signal === "SIGTERM" ? 143 : 130;
+	if (process.platform === "linux" && process.pid === 1) process.exit(exitCode);
+	try {
+		process.kill(process.pid, signal);
+	} catch {
+		process.exit(exitCode);
+	}
 }
 async function waitForSignalDeadline(promise) {
-  let deadlineTimer;
-  const deadlineReached = new Promise((resolve) => {
-    deadlineTimer = setTimeout(resolve, SIGNAL_FLUSH_TIMEOUT_MILLIS);
-  });
-  try {
-    await Promise.race([promise, deadlineReached]);
-  } finally {
-    if (deadlineTimer) {
-      clearTimeout(deadlineTimer);
-    }
-  }
+	let deadlineTimer;
+	const deadlineReached = new Promise((resolve) => {
+		deadlineTimer = setTimeout(resolve, SIGNAL_FLUSH_TIMEOUT_MILLIS);
+	});
+	try {
+		await Promise.race([promise, deadlineReached]);
+	} finally {
+		if (deadlineTimer) clearTimeout(deadlineTimer);
+	}
 }
 function removeSignalHooks(activationState, listeners = activationState.signalListeners) {
-  if (!listeners) {
-    return;
-  }
-  process.removeListener("SIGTERM", listeners.SIGTERM);
-  process.removeListener("SIGINT", listeners.SIGINT);
-  if (activationState.signalListeners === listeners) {
-    activationState.signalListeners = void 0;
-  }
+	if (!listeners) return;
+	process.removeListener("SIGTERM", listeners.SIGTERM);
+	process.removeListener("SIGINT", listeners.SIGINT);
+	if (activationState.signalListeners === listeners) activationState.signalListeners = void 0;
 }
 function removeLifecycleHooks(activationState) {
-  removeSignalHooks(activationState);
-  if (activationState.beforeExitListener) {
-    process.removeListener("beforeExit", activationState.beforeExitListener);
-    activationState.beforeExitListener = void 0;
-  }
+	removeSignalHooks(activationState);
+	if (activationState.beforeExitListener) {
+		process.removeListener("beforeExit", activationState.beforeExitListener);
+		activationState.beforeExitListener = void 0;
+	}
 }
 function installBeforeExitHook(activationState) {
-  const listener = () => {
-    void shutdown().catch((error) => {
-      (0, import_logger.logDebug)(`Error draining telemetry on shutdown: ${String(error)}`);
-    });
-  };
-  activationState.beforeExitListener = listener;
-  process.on("beforeExit", listener);
+	const listener = () => {
+		shutdown().catch((error) => {
+			require_logger.logDebug(`Error draining telemetry on shutdown: ${String(error)}`);
+		});
+	};
+	activationState.beforeExitListener = listener;
+	process.on("beforeExit", listener);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  activate,
-  activationFactories,
-  configure,
-  flushTelemetry,
-  getActivationHandles,
-  isActivated,
-  registerStartupEventInfo,
-  resetActivation,
-  shutdown
-});
+//#endregion
+exports.activate = activate;
+exports.activationFactories = activationFactories;
+exports.configure = configure;
+exports.flushTelemetry = flushTelemetry;
+exports.getActivationHandles = getActivationHandles;
+exports.isActivated = isActivated;
+exports.registerStartupEventInfo = registerStartupEventInfo;
+exports.resetActivation = resetActivation;
+exports.shutdown = shutdown;
+
 //# sourceMappingURL=activation.cjs.map