apitally 0.25.6 → 1.0.0-alpha.1

package/dist/activation.cjs

@@ -0,0 +1,371 @@
+"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_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_spanExporter = require('./spanExporter.cjs');
+var import_spanProcessor = require('./spanProcessor.cjs');
+var import_spool = require('./spool.cjs');
+var import_startup = require('./startup.cjs');
+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");
+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;
+}
+function registerStartupEventInfo(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 isActivated() {
+  return getActivationState().handles !== void 0;
+}
+function getActivationHandles() {
+  return getActivationState().handles;
+}
+async function flushTelemetry() {
+  try {
+    await getActivationState().handles?.worker.runCycle();
+  } catch (error) {
+    (0, import_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 activationFactories = {
+  createSpool: () => new import_spool.Spool(),
+  createExportWorker: (options) => new import_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;
+  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 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;
+}
+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;
+}
+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);
+  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(),
+    () => 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 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;
+      }
+    }
+  });
+}
+async function drainAndStop(handles) {
+  try {
+    await handles.spanPipeline.shutdown();
+    await handles.loggerProvider.shutdown();
+    await handles.worker.finalDrain();
+    await handles.worker.stop();
+  } catch (error) {
+    (0, import_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)}`);
+  }
+}
+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)}`);
+  });
+}
+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);
+  }
+}
+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);
+    }
+  }
+}
+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;
+  }
+}
+function removeLifecycleHooks(activationState) {
+  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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate,
+  activationFactories,
+  configure,
+  flushTelemetry,
+  getActivationHandles,
+  isActivated,
+  registerStartupEventInfo,
+  resetActivation,
+  shutdown
+});
+//# sourceMappingURL=activation.cjs.map

package/dist/activation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/activation.ts"],"sourcesContent":["import { isMainThread } from \"node:worker_threads\";\nimport { UndiciInstrumentation } from \"@opentelemetry/instrumentation-undici\";\nimport { BatchLogRecordProcessor, type LoggerProvider } from \"@opentelemetry/sdk-logs\";\nimport { BatchSpanProcessor, type Span } from \"@opentelemetry/sdk-trace-base\";\nimport type { NodeTracerProvider } from \"@opentelemetry/sdk-trace-node\";\nimport {\n  type ApitallyConfig,\n  type ApitallyOptions,\n  getConfig,\n  isApitallyDisabledViaEnv,\n  setConfig,\n} from \"./config.js\";\nimport { ExportWorker, type ExportWorkerOptions } from \"./exportWorker.js\";\nimport {\n  installConsoleCapture,\n  installNestLoggerCapture,\n  installPinoCapture,\n  installWinstonCapture,\n} from \"./logCapture.js\";\nimport { logDebug, logError, logWarning } from \"./logger.js\";\nimport { ApitallyLogRecordExporter } from \"./logRecordExporter.js\";\nimport { ApitallyLogRecordProcessor } from \"./logRecordProcessor.js\";\nimport { MetricsPipeline } from \"./metrics.js\";\nimport { getDistroVersion } from \"./packageVersion.js\";\nimport {\n  createLoggerProvider,\n  resolveEnvAndCreateResource,\n  setupTracerProvider,\n} from \"./providers.js\";\nimport { Redaction } from \"./redaction.js\";\nimport { installSentryEventIdRecording } from \"./sentry.js\";\nimport { ApitallySpanExporter } from \"./spanExporter.js\";\nimport {\n  isApitallySpanProcessorDeclared,\n  SpanPipeline,\n  setActiveSpanPipeline,\n  setServerSpanActivationCallback,\n} from \"./spanProcessor.js\";\nimport { Spool } from \"./spool.js\";\nimport { emitStartupEvent, type StartupEventInfo } from \"./startup.js\";\n\n// The worker sends every 15 seconds, so batches only need to reach the spool\n// within that interval.\nconst BATCH_SCHEDULE_DELAY_MILLIS = 1_000;\nconst BATCH_EXPORT_TIMEOUT_MILLIS = 30_000;\nconst BATCH_MAX_QUEUE_SIZE = 2_048;\nconst BATCH_MAX_EXPORT_BATCH_SIZE = 512;\nconst BATCH_MAX_EXPORT_BATCH_SIZE_WITH_BODY_CAPTURE = 32;\nconst SIGNAL_FLUSH_TIMEOUT_MILLIS = 5_000;\n\ntype TerminationSignal = \"SIGTERM\" | \"SIGINT\";\ntype SignalListeners = Record<TerminationSignal, () => void>;\n\n// The ESM and CJS builds can load together, so a Symbol.for key gives both\n// copies the same activation state.\nconst ACTIVATION_STATE_KEY = Symbol.for(\"apitally.activation\");\n\ninterface ActivationState {\n  sdkVersion: string;\n  activationAttempted: boolean;\n  startupEventInfo?: StartupEventInfo;\n  handles?: ActivationHandles;\n  runShutdown?: () => Promise<void>;\n  shutdownPromise?: Promise<void>;\n  beforeExitListener?: () => void;\n  signalListeners?: SignalListeners;\n  signalDrainPromise?: Promise<void>;\n}\n\ninterface ActivationHandles {\n  spanPipeline: SpanPipeline;\n  tracerProvider?: NodeTracerProvider;\n  loggerProvider: LoggerProvider;\n  metricsPipeline: MetricsPipeline;\n  spool: Spool;\n  worker: ExportWorker;\n  undiciInstrumentation?: UndiciInstrumentation;\n}\n\n// Configuration stays synchronous; activate() defers timers and I/O.\nexport function configure(options: ApitallyOptions = {}): ApitallyConfig {\n  const config = setConfig(options);\n  // User instrumentations read this at initialization. `http/dup` adds stable\n  // HTTP attributes alongside legacy ones; a user-set value takes precedence.\n  if (!config.disabled && process.env.OTEL_SEMCONV_STABILITY_OPT_IN === undefined) {\n    process.env.OTEL_SEMCONV_STABILITY_OPT_IN = \"http/dup\";\n  }\n  setServerSpanActivationCallback(activate);\n  return config;\n}\n\n// The first integration registration wins so one process emits one startup event.\nexport function registerStartupEventInfo(info: StartupEventInfo): void {\n  const activationState = getActivationState();\n  activationState.startupEventInfo ??= info;\n}\n\n// Activation is synchronous and attempted once, so concurrent first requests\n// observe either no activation or completed activation.\nexport function activate(triggeringSpan?: Span): void {\n  const activationState = getActivationState();\n  if (activationState.activationAttempted) {\n    return;\n  }\n  activationState.activationAttempted = true;\n  if (shouldSkipActivation()) {\n    return;\n  }\n  try {\n    const handles = startPipelines(activationState.startupEventInfo, triggeringSpan);\n    activationState.handles = handles;\n    activationState.runShutdown = () => drainAndStop(handles);\n    installBeforeExitHook(activationState);\n    installSignalHooks(activationState);\n  } catch (error) {\n    logError(`Apitally activation failed: ${String(error)}`);\n  }\n}\n\nexport function isActivated(): boolean {\n  return getActivationState().handles !== undefined;\n}\n\nexport function getActivationHandles(): ActivationHandles | undefined {\n  return getActivationState().handles;\n}\n\nexport async function flushTelemetry(): Promise<void> {\n  try {\n    await getActivationState().handles?.worker.runCycle();\n  } catch (error) {\n    logDebug(`Error flushing telemetry: ${String(error)}`);\n  }\n}\n\n// Concurrent calls and lifecycle hooks share one final drain; calls before\n// activation are no-ops.\nexport function shutdown(): Promise<void> {\n  const activationState = getActivationState();\n  const handles = activationState.handles;\n  const runShutdown = activationState.runShutdown;\n  if (!handles || !runShutdown) {\n    return Promise.resolve();\n  }\n  if (!activationState.shutdownPromise) {\n    removeLifecycleHooks(activationState);\n    const signalDrainPromise = activationState.signalDrainPromise;\n    activationState.shutdownPromise = (\n      signalDrainPromise\n        ? signalDrainPromise.then(() => handles.worker.waitForIdle())\n        : Promise.resolve()\n    ).then(runShutdown);\n  }\n  return activationState.shutdownPromise;\n}\n\n// Tests replace these factories to isolate spool files and worker timing.\nexport const activationFactories = {\n  createSpool: (): Spool => new Spool(),\n  createExportWorker: (options: ExportWorkerOptions): ExportWorker => new ExportWorker(options),\n};\nconst defaultFactories = { ...activationFactories };\n\n// Tests reset process-global activation and its side effects between cases.\nexport async function resetActivation(): Promise<void> {\n  Object.assign(activationFactories, defaultFactories);\n  const holder = globalThis as Record<symbol, ActivationState | undefined>;\n  const activationState = holder[ACTIVATION_STATE_KEY];\n  delete holder[ACTIVATION_STATE_KEY];\n  hasWarnedAboutVersionSkew = false;\n  if (!activationState) {\n    return;\n  }\n  removeLifecycleHooks(activationState);\n  const handles = activationState.handles;\n  if (!handles) {\n    return;\n  }\n  handles.undiciInstrumentation?.disable();\n  await handles.worker.stop();\n  await handles.spanPipeline.shutdown();\n  await handles.loggerProvider.shutdown();\n  await handles.spool.clear();\n}\n\nlet hasWarnedAboutVersionSkew = false;\n\nfunction getActivationState(): ActivationState {\n  const holder = globalThis as Record<symbol, ActivationState | undefined>;\n  const existing = holder[ACTIVATION_STATE_KEY];\n  if (existing) {\n    if (!hasWarnedAboutVersionSkew && existing.sdkVersion !== getDistroVersion()) {\n      hasWarnedAboutVersionSkew = true;\n      logWarning(\n        `Two copies of the apitally package with different versions (${existing.sdkVersion} and ${getDistroVersion()}) are loaded in this process; version ${existing.sdkVersion} stays active. To resolve this, deduplicate the apitally installation.`,\n      );\n    }\n    return existing;\n  }\n  const activationState: ActivationState = {\n    sdkVersion: getDistroVersion(),\n    activationAttempted: false,\n  };\n  holder[ACTIVATION_STATE_KEY] = activationState;\n  return activationState;\n}\n\nfunction shouldSkipActivation(): boolean {\n  return (\n    Boolean(process.env.JEST_WORKER_ID) ||\n    Boolean(process.env.VITEST) ||\n    process.env.NODE_ENV === \"test\" ||\n    // The emergency kill switch overrides an explicit disabled: false option.\n    isApitallyDisabledViaEnv() ||\n    getConfig().disabled\n  );\n}\n\nfunction startPipelines(\n  startupEventInfo: StartupEventInfo | undefined,\n  triggeringSpan?: Span,\n): ActivationHandles {\n  const config = getConfig();\n  let hasUserProvider = isApitallySpanProcessorDeclared();\n  const { env, resource } = resolveEnvAndCreateResource(hasUserProvider, triggeringSpan?.resource);\n  const instanceId = resource.attributes[\"service.instance.id\"] as string;\n  const spool = activationFactories.createSpool();\n  const spanExporter = new ApitallySpanExporter({\n    redaction: new Redaction(),\n    env,\n    instanceId,\n    spool,\n    maskRequestBody: config.maskRequestBody,\n    maskResponseBody: config.maskResponseBody,\n  });\n  // Concrete options prevent OTel environment variables from changing batch\n  // behavior. Each processor gets a fresh object because its config is mutated.\n  const batchSpanProcessor = new BatchSpanProcessor(spanExporter, {\n    scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,\n    exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,\n    maxQueueSize: BATCH_MAX_QUEUE_SIZE,\n    maxExportBatchSize:\n      config.captureRequestBody || config.captureResponseBody\n        ? BATCH_MAX_EXPORT_BATCH_SIZE_WITH_BODY_CAPTURE\n        : BATCH_MAX_EXPORT_BATCH_SIZE,\n  });\n  const spanPipeline = new SpanPipeline(batchSpanProcessor);\n  let tracerProvider: NodeTracerProvider | undefined;\n  if (!hasUserProvider) {\n    tracerProvider = setupTracerProvider(resource, [spanPipeline]);\n    if (!tracerProvider) {\n      hasUserProvider = true;\n      logWarning(\n        \"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.\",\n      );\n    }\n  }\n  setActiveSpanPipeline(spanPipeline);\n  // BatchLogRecordProcessor requires its single-options-object form; positional\n  // arguments create a broken processor.\n  const batchLogProcessor = new BatchLogRecordProcessor({\n    exporter: new ApitallyLogRecordExporter(spool),\n    scheduledDelayMillis: BATCH_SCHEDULE_DELAY_MILLIS,\n    exportTimeoutMillis: BATCH_EXPORT_TIMEOUT_MILLIS,\n    maxQueueSize: BATCH_MAX_QUEUE_SIZE,\n    maxExportBatchSize: BATCH_MAX_EXPORT_BATCH_SIZE,\n  });\n  const logRecordProcessor = new ApitallyLogRecordProcessor(batchLogProcessor, spanPipeline);\n  const loggerProvider = createLoggerProvider(resource, [logRecordProcessor]);\n  const metricsPipeline = new MetricsPipeline(resource, spool);\n  spanPipeline.metricsRecorder = (record) => metricsPipeline.recordFromRequest(record);\n  const worker = activationFactories.createExportWorker({\n    spool,\n    otlpEndpoint: config.otlpEndpoint,\n    writeToken: config.writeToken,\n    env,\n  });\n  worker.flushCallbacks.push(\n    () => metricsPipeline.collectAndExport(),\n    () => batchSpanProcessor.forceFlush(),\n    () => batchLogProcessor.forceFlush(),\n  );\n  if (config.captureLogs) {\n    installConsoleCapture(loggerProvider);\n    installNestLoggerCapture(loggerProvider);\n    installWinstonCapture(loggerProvider);\n    installPinoCapture(loggerProvider);\n  }\n  installSentryEventIdRecording();\n  let undiciInstrumentation: UndiciInstrumentation | undefined;\n  if (!hasUserProvider) {\n    undiciInstrumentation = createUndiciInstrumentation(config.otlpEndpoint);\n  }\n  worker.start();\n  if (startupEventInfo) {\n    emitStartupEvent(loggerProvider, startupEventInfo);\n  }\n  return {\n    spanPipeline,\n    tracerProvider,\n    loggerProvider,\n    metricsPipeline,\n    spool,\n    worker,\n    undiciInstrumentation,\n  };\n}\n\n// ignoreRequestHook prevents telemetry for export POSTs. The request origin can\n// be a string or URL at runtime despite its string type.\nfunction createUndiciInstrumentation(otlpEndpoint: string): UndiciInstrumentation {\n  const endpointOrigin = new URL(otlpEndpoint).origin;\n  return new UndiciInstrumentation({\n    ignoreRequestHook: (request) => {\n      try {\n        return new URL(String(request.origin)).origin === endpointOrigin;\n      } catch {\n        return false;\n      }\n    },\n  });\n}\n\nasync function drainAndStop(handles: ActivationHandles): Promise<void> {\n  try {\n    await handles.spanPipeline.shutdown();\n    await handles.loggerProvider.shutdown();\n    await handles.worker.finalDrain();\n    await handles.worker.stop();\n  } catch (error) {\n    logWarning(`Error draining telemetry on shutdown: ${String(error)}`);\n  }\n}\n\nfunction installSignalHooks(activationState: ActivationState): void {\n  if (process.platform === \"win32\" || !isMainThread) {\n    return;\n  }\n  let listeners: SignalListeners;\n  listeners = {\n    SIGTERM: () => handleTerminationSignal(activationState, listeners, \"SIGTERM\"),\n    SIGINT: () => handleTerminationSignal(activationState, listeners, \"SIGINT\"),\n  };\n  activationState.signalListeners = listeners;\n  try {\n    process.prependOnceListener(\"SIGTERM\", listeners.SIGTERM);\n    process.prependOnceListener(\"SIGINT\", listeners.SIGINT);\n  } catch (error) {\n    removeSignalHooks(activationState, listeners);\n    logWarning(`Unable to install Apitally signal handlers: ${String(error)}`);\n  }\n}\n\nfunction handleTerminationSignal(\n  activationState: ActivationState,\n  listeners: SignalListeners,\n  signal: TerminationSignal,\n): void {\n  const hasApplicationListener = process\n    .listeners(signal)\n    .some((listener) => listener !== listeners[signal]);\n  removeSignalHooks(activationState, listeners);\n  const drainPromise = flushAfterTerminationSignal(activationState, signal, hasApplicationListener);\n  activationState.signalDrainPromise = drainPromise;\n  void drainPromise.catch((error: unknown) => {\n    logDebug(`Error flushing telemetry on ${signal}: ${String(error)}`);\n  });\n}\n\nasync function flushAfterTerminationSignal(\n  activationState: ActivationState,\n  signal: TerminationSignal,\n  hasApplicationListener: boolean,\n): Promise<void> {\n  const handles = activationState.handles;\n  if (!handles) {\n    return;\n  }\n  try {\n    if (activationState.shutdownPromise) {\n      await waitForSignalDeadline(activationState.shutdownPromise);\n    } else {\n      await handles.worker.finalDrain(SIGNAL_FLUSH_TIMEOUT_MILLIS);\n    }\n  } catch (error) {\n    logDebug(`Error flushing telemetry on ${signal}: ${String(error)}`);\n  }\n  if (hasApplicationListener || process.listeners(signal).length > 0) {\n    return;\n  }\n  const exitCode = signal === \"SIGTERM\" ? 143 : 130;\n  if (process.platform === \"linux\" && process.pid === 1) {\n    process.exit(exitCode);\n  }\n  try {\n    process.kill(process.pid, signal);\n  } catch {\n    process.exit(exitCode);\n  }\n}\n\nasync function waitForSignalDeadline(promise: Promise<void>): Promise<void> {\n  let deadlineTimer: NodeJS.Timeout | undefined;\n  const deadlineReached = new Promise<void>((resolve) => {\n    deadlineTimer = setTimeout(resolve, SIGNAL_FLUSH_TIMEOUT_MILLIS);\n  });\n  try {\n    await Promise.race([promise, deadlineReached]);\n  } finally {\n    if (deadlineTimer) {\n      clearTimeout(deadlineTimer);\n    }\n  }\n}\n\nfunction removeSignalHooks(\n  activationState: ActivationState,\n  listeners = activationState.signalListeners,\n): void {\n  if (!listeners) {\n    return;\n  }\n  process.removeListener(\"SIGTERM\", listeners.SIGTERM);\n  process.removeListener(\"SIGINT\", listeners.SIGINT);\n  if (activationState.signalListeners === listeners) {\n    activationState.signalListeners = undefined;\n  }\n}\n\nfunction removeLifecycleHooks(activationState: ActivationState): void {\n  removeSignalHooks(activationState);\n  if (activationState.beforeExitListener) {\n    process.removeListener(\"beforeExit\", activationState.beforeExitListener);\n    activationState.beforeExitListener = undefined;\n  }\n}\n\nfunction installBeforeExitHook(activationState: ActivationState): void {\n  const listener = () => {\n    // The drain keeps the event loop alive until shutdown settles.\n    void shutdown().catch((error: unknown) => {\n      logDebug(`Error draining telemetry on shutdown: ${String(error)}`);\n    });\n  };\n  activationState.beforeExitListener = listener;\n  process.on(\"beforeExit\", listener);\n}\n"],"mappings":"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","names":[]}

package/dist/activation.d.cts

@@ -0,0 +1,41 @@
+import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { Span } from '@opentelemetry/sdk-trace-base';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ApitallyOptions, ApitallyConfig } from './config.cjs';
+import { ExportWorkerOptions, ExportWorker } from './exportWorker.cjs';
+import { MetricsPipeline } from './metrics.cjs';
+import { SpanPipeline } from './spanProcessor.cjs';
+import { Spool } from './spool.cjs';
+import { StartupEventInfo } from './startup.cjs';
+import '@opentelemetry/resources';
+import '@opentelemetry/sdk-metrics';
+import './context.cjs';
+import '@opentelemetry/api';
+import '@opentelemetry/core';
+import 'node:zlib';
+import '@opentelemetry/api-logs';
+
+interface ActivationHandles {
+    spanPipeline: SpanPipeline;
+    tracerProvider?: NodeTracerProvider;
+    loggerProvider: LoggerProvider;
+    metricsPipeline: MetricsPipeline;
+    spool: Spool;
+    worker: ExportWorker;
+    undiciInstrumentation?: UndiciInstrumentation;
+}
+declare function configure(options?: ApitallyOptions): ApitallyConfig;
+declare function registerStartupEventInfo(info: StartupEventInfo): void;
+declare function activate(triggeringSpan?: Span): void;
+declare function isActivated(): boolean;
+declare function getActivationHandles(): ActivationHandles | undefined;
+declare function flushTelemetry(): Promise<void>;
+declare function shutdown(): Promise<void>;
+declare const activationFactories: {
+    createSpool: () => Spool;
+    createExportWorker: (options: ExportWorkerOptions) => ExportWorker;
+};
+declare function resetActivation(): Promise<void>;
+
+export { activate, activationFactories, configure, flushTelemetry, getActivationHandles, isActivated, registerStartupEventInfo, resetActivation, shutdown };

package/dist/activation.d.ts

@@ -0,0 +1,41 @@
+import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { Span } from '@opentelemetry/sdk-trace-base';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ApitallyOptions, ApitallyConfig } from './config.js';
+import { ExportWorkerOptions, ExportWorker } from './exportWorker.js';
+import { MetricsPipeline } from './metrics.js';
+import { SpanPipeline } from './spanProcessor.js';
+import { Spool } from './spool.js';
+import { StartupEventInfo } from './startup.js';
+import '@opentelemetry/resources';
+import '@opentelemetry/sdk-metrics';
+import './context.js';
+import '@opentelemetry/api';
+import '@opentelemetry/core';
+import 'node:zlib';
+import '@opentelemetry/api-logs';
+
+interface ActivationHandles {
+    spanPipeline: SpanPipeline;
+    tracerProvider?: NodeTracerProvider;
+    loggerProvider: LoggerProvider;
+    metricsPipeline: MetricsPipeline;
+    spool: Spool;
+    worker: ExportWorker;
+    undiciInstrumentation?: UndiciInstrumentation;
+}
+declare function configure(options?: ApitallyOptions): ApitallyConfig;
+declare function registerStartupEventInfo(info: StartupEventInfo): void;
+declare function activate(triggeringSpan?: Span): void;
+declare function isActivated(): boolean;
+declare function getActivationHandles(): ActivationHandles | undefined;
+declare function flushTelemetry(): Promise<void>;
+declare function shutdown(): Promise<void>;
+declare const activationFactories: {
+    createSpool: () => Spool;
+    createExportWorker: (options: ExportWorkerOptions) => ExportWorker;
+};
+declare function resetActivation(): Promise<void>;
+
+export { activate, activationFactories, configure, flushTelemetry, getActivationHandles, isActivated, registerStartupEventInfo, resetActivation, shutdown };