apitally 0.25.7 → 1.0.0-alpha.1

package/dist/spanProcessor.cjs

@@ -0,0 +1,523 @@
+"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 spanProcessor_exports = {};
+__export(spanProcessor_exports, {
+  ApitallySpanProcessor: () => ApitallySpanProcessor,
+  SpanPipeline: () => SpanPipeline,
+  copySpan: () => copySpan,
+  getActiveSpanPipeline: () => getActiveSpanPipeline,
+  isApitallySpanProcessorDeclared: () => isApitallySpanProcessorDeclared,
+  resetSpanProcessorState: () => resetSpanProcessorState,
+  setActiveSpanPipeline: () => setActiveSpanPipeline,
+  setServerSpanActivationCallback: () => setServerSpanActivationCallback
+});
+module.exports = __toCommonJS(spanProcessor_exports);
+var import_api = require("@opentelemetry/api");
+var import_core = require("@opentelemetry/core");
+var import_config = require('./config.cjs');
+var import_consumer = require('./consumer.cjs');
+var import_context = require('./context.cjs');
+var import_logger = require('./logger.cjs');
+const MAX_BUFFERED_SPANS = 1e3;
+const MAX_TRACKED_SPAN_IDS = MAX_BUFFERED_SPANS + 1;
+const MAX_STASHED_REQUESTS = 2048;
+const MAX_KEPT_SPAN_IDS = 1e4;
+const EXCLUDE_USER_AGENT_PATTERNS = (0, import_config.compilePatterns)(import_config.EXCLUDE_USER_AGENTS);
+class ApitallySpanProcessor {
+  constructor() {
+    setApitallySpanProcessorDeclared();
+  }
+  onStart(span, parentContext) {
+    let pipeline = getActiveSpanPipeline();
+    if (!pipeline && span.kind === import_api.SpanKind.SERVER) {
+      getServerSpanActivationCallback()?.(span);
+      pipeline = getActiveSpanPipeline();
+    }
+    pipeline?.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    getActiveSpanPipeline()?.onEnd(span);
+  }
+  // Flush failures resolve instead of rejecting into the user's provider.
+  forceFlush() {
+    const pipeline = getActiveSpanPipeline();
+    if (!pipeline) {
+      return Promise.resolve();
+    }
+    return pipeline.forceFlush().catch((error) => {
+      (0, import_logger.logDebug)(`Error flushing spans: ${String(error)}`);
+    });
+  }
+  // A user provider's shutdown only flushes released requests; SDK shutdown owns
+  // teardown.
+  shutdown() {
+    return this.forceFlush();
+  }
+}
+const ACTIVE_SPAN_PIPELINE_KEY = /* @__PURE__ */ Symbol.for("apitally.activeSpanPipeline");
+const APITALLY_SPAN_PROCESSOR_DECLARED_KEY = /* @__PURE__ */ Symbol.for("apitally.spanProcessorDeclared");
+const SERVER_SPAN_ACTIVATION_CALLBACK_KEY = /* @__PURE__ */ Symbol.for("apitally.serverSpanActivationCallback");
+function setActiveSpanPipeline(pipeline) {
+  globalThis[ACTIVE_SPAN_PIPELINE_KEY] = pipeline;
+}
+function getActiveSpanPipeline() {
+  return globalThis[ACTIVE_SPAN_PIPELINE_KEY];
+}
+function setServerSpanActivationCallback(callback) {
+  const holder = globalThis;
+  holder[SERVER_SPAN_ACTIVATION_CALLBACK_KEY] ??= callback;
+}
+function isApitallySpanProcessorDeclared() {
+  return globalThis[APITALLY_SPAN_PROCESSOR_DECLARED_KEY] === true;
+}
+function resetSpanProcessorState() {
+  const holder = globalThis;
+  delete holder[ACTIVE_SPAN_PIPELINE_KEY];
+  delete holder[APITALLY_SPAN_PROCESSOR_DECLARED_KEY];
+  delete holder[SERVER_SPAN_ACTIVATION_CALLBACK_KEY];
+}
+function setApitallySpanProcessorDeclared() {
+  globalThis[APITALLY_SPAN_PROCESSOR_DECLARED_KEY] = true;
+}
+function getServerSpanActivationCallback() {
+  return globalThis[SERVER_SPAN_ACTIVATION_CALLBACK_KEY];
+}
+class SpanPipeline {
+  // Callbacks are optional because metrics and log pipelines start at activation.
+  metricsRecorder;
+  onRequestFinished;
+  downstream;
+  config;
+  sampleRateBound;
+  excludePathPatterns;
+  // Every span ID remains mapped to one request until completion so late logs
+  // resolve. A miss means dropped, completed, or non-request telemetry.
+  requests = /* @__PURE__ */ new Map();
+  stash = /* @__PURE__ */ new Map();
+  demotedSpanIds = /* @__PURE__ */ new Set();
+  // Kept span IDs remain resolvable after release for late spans and logs; the
+  // oldest are evicted at the cap.
+  keptSpanIds = /* @__PURE__ */ new Map();
+  constructor(downstream) {
+    this.downstream = downstream;
+    this.config = (0, import_config.getConfig)();
+    this.sampleRateBound = boundForSampleRate(this.config.sampleRate);
+    this.excludePathPatterns = (0, import_config.compilePatterns)(import_config.DEFAULT_EXCLUDE_PATHS, this.config.excludePaths);
+  }
+  onStart(span, parentContext) {
+    try {
+      if (isContribPerMessageSpan(span)) {
+        return;
+      }
+      const parent = span.parentSpanContext;
+      if (!parent || parent.isRemote) {
+        if (span.kind === import_api.SpanKind.SERVER) {
+          this.startRequest(span, parentContext);
+        }
+        return;
+      }
+      const entry = this.requests.get(parent.spanId);
+      const spanId = span.spanContext().spanId;
+      if (!entry) {
+        const kept = this.keptSpanIds.get(parent.spanId);
+        if (kept) {
+          this.addKeptSpanId(spanId, {
+            serverSpanId: kept.serverSpanId,
+            demoted: false
+          });
+        }
+        return;
+      }
+      if (entry.spanIds.size >= MAX_TRACKED_SPAN_IDS) {
+        (0, import_logger.logDebug)("Apitally span tracking cap reached, dropping the span");
+        return;
+      }
+      if (span.kind === import_api.SpanKind.SERVER) {
+        this.demotedSpanIds.add(spanId);
+        (0, import_logger.logWarning)(
+          `Detected a duplicate SERVER span produced by the instrumentation scope "${span.instrumentationScope?.name ?? "unknown"}" inside an active request. Apitally exports it as an INTERNAL span, but your own OpenTelemetry exporters still receive the duplicate. To resolve this, remove the middleware that produces it.`
+        );
+      }
+      this.requests.set(spanId, entry);
+      entry.spanIds.add(spanId);
+    } catch (error) {
+      (0, import_logger.logWarning)(`Error in the Apitally span processor: ${String(error)}`);
+    }
+  }
+  onEnd(span) {
+    try {
+      const spanId = span.spanContext().spanId;
+      const isDemoted = this.demotedSpanIds.delete(spanId);
+      const entry = this.requests.get(spanId);
+      if (!entry) {
+        const kept = this.keptSpanIds.get(spanId);
+        if (kept) {
+          let exportSpan2 = span;
+          if (kept.demoted) {
+            const copy = copySpan(span);
+            copy.apitallyData = { demoteToInternal: true };
+            exportSpan2 = copy;
+          }
+          this.downstream.onEnd(exportSpan2);
+        }
+        return;
+      }
+      if (spanId === entry.serverSpanId) {
+        entry.endedServerSpan = span;
+        this.releaseIfComplete(entry);
+        return;
+      }
+      let exportSpan = span;
+      if (isDemoted) {
+        const copy = copySpan(span);
+        copy.apitallyData = { demoteToInternal: true };
+        exportSpan = copy;
+      }
+      if (entry.buffered.length < MAX_BUFFERED_SPANS) {
+        entry.buffered.push(exportSpan);
+      } else {
+        (0, import_logger.logDebug)("Apitally span buffer cap reached, dropping the span");
+      }
+    } catch (error) {
+      (0, import_logger.logWarning)(`Error in the Apitally span processor: ${String(error)}`);
+    }
+  }
+  // Transport completion triggers response sampling and metrics independently
+  // of span-end timing. Map misses still record metrics and discard other data.
+  handleTransportCompletion(record) {
+    try {
+      record.dropReason = resolveTransportDropReason(record.attributes) ?? record.dropReason;
+      const entry = record.serverSpanId !== void 0 ? this.requests.get(record.serverSpanId) : void 0;
+      if (entry && !entry.transportCompleted && !entry.released) {
+        entry.record ??= record;
+        entry.transportCompleted = true;
+        if (!this.isResponseSampledIn(entry)) {
+          this.dropRequestOnResponse(entry, record);
+        }
+      }
+      this.metricsRecorder?.(record);
+      if (entry) {
+        this.releaseIfComplete(entry);
+      }
+    } catch (error) {
+      (0, import_logger.logWarning)(`Error in the Apitally span processor: ${String(error)}`);
+    }
+  }
+  // Holds captured headers and bodies until the exporter attaches them to the
+  // exported SERVER span copy. Fields already stashed are kept unless replaced.
+  updateStash(serverSpanId, update) {
+    try {
+      if (!this.requests.has(serverSpanId)) {
+        return;
+      }
+      let entry = this.stash.get(serverSpanId);
+      if (!entry) {
+        if (this.stash.size >= MAX_STASHED_REQUESTS) {
+          const oldestKey = this.stash.keys().next().value;
+          if (oldestKey !== void 0) {
+            this.stash.delete(oldestKey);
+            (0, import_logger.logDebug)("Apitally payload stash cap reached, dropping the oldest entry");
+          }
+        }
+        entry = {};
+        this.stash.set(serverSpanId, entry);
+      }
+      if (update.requestHeaders !== void 0) {
+        entry.requestHeaders = update.requestHeaders;
+      }
+      if (update.requestBody !== void 0) {
+        entry.requestBody = update.requestBody;
+      }
+      if (update.responseHeaders !== void 0) {
+        entry.responseHeaders = update.responseHeaders;
+      }
+      if (update.responseBody !== void 0) {
+        entry.responseBody = update.responseBody;
+      }
+    } catch (error) {
+      (0, import_logger.logDebug)(`Error updating the request stash: ${String(error)}`);
+    }
+  }
+  // Kept requests remain resolvable after release so late logs retain their
+  // request association.
+  resolveServerSpanId(spanId) {
+    return this.requests.get(spanId)?.serverSpanId ?? this.keptSpanIds.get(spanId)?.serverSpanId;
+  }
+  isRequestInFlight(serverSpanId) {
+    return this.requests.has(serverSpanId);
+  }
+  // Exclusion answers "never wanted" and runs strictly before sampling; an
+  // excluded request never invokes a user sampling callback.
+  resolveRequestDropReasonBeforeSampling(attributes) {
+    const transportDropReason = resolveTransportDropReason(attributes);
+    if (transportDropReason !== void 0) {
+      return transportDropReason;
+    }
+    const path = attributes["url.path"] ?? attributes["http.target"];
+    if (typeof path === "string" && (0, import_config.matchesAny)(this.excludePathPatterns, path.split("?")[0])) {
+      return "excluded";
+    }
+    const userAgent = attributes["user_agent.original"] ?? attributes["http.user_agent"];
+    if (typeof userAgent === "string" && (0, import_config.matchesAny)(EXCLUDE_USER_AGENT_PATTERNS, userAgent)) {
+      return "excluded";
+    }
+    return void 0;
+  }
+  forceFlush() {
+    return this.downstream.forceFlush();
+  }
+  // Shutdown releases requests with completed transport observation once and
+  // discards incomplete requests, which cannot complete afterward.
+  async shutdown() {
+    try {
+      for (const entry of new Set(this.requests.values())) {
+        if (!entry.released && entry.transportCompleted) {
+          this.releaseRequest(entry, entry.endedServerSpan ?? entry.serverSpan);
+        }
+      }
+      this.requests.clear();
+      this.stash.clear();
+      this.demotedSpanIds.clear();
+      this.keptSpanIds.clear();
+    } catch (error) {
+      (0, import_logger.logWarning)(`Error in the Apitally span processor: ${String(error)}`);
+    }
+    await this.downstream.shutdown();
+  }
+  startRequest(span, parentContext) {
+    const spanId = span.spanContext().spanId;
+    const handle = parentContext.getValue(import_context.SPAN_HANDLE_KEY);
+    if (handle) {
+      handle.span = span;
+    }
+    const record = parentContext.getValue(import_context.REQUEST_RECORD_KEY);
+    if (record) {
+      record.serverSpanId = spanId;
+    }
+    (0, import_consumer.writeConsumerAttributesFromContext)(parentContext, span, record);
+    writeUrlAttributesFromFullUrl(span);
+    const dropReason = this.resolveRequestDropReasonBeforeSampling(span.attributes) ?? (this.isRequestSampledIn(span) ? void 0 : "sampled-out");
+    if (dropReason) {
+      if (record) {
+        record.dropReason = dropReason;
+      }
+      return;
+    }
+    this.requests.set(spanId, {
+      serverSpanId: spanId,
+      serverSpan: span,
+      spanIds: /* @__PURE__ */ new Set([spanId]),
+      record,
+      buffered: [],
+      transportCompleted: false,
+      released: false
+    });
+  }
+  isRequestSampledIn(span) {
+    const callback = this.config.sampleOnRequest;
+    const rate = callback ? resolveCallbackSampleRate(callback, span, "sampleOnRequest") : void 0;
+    const bound = rate === void 0 ? this.sampleRateBound : boundForSampleRate(rate);
+    return isTraceSampledIn(span.spanContext().traceId, bound);
+  }
+  // Abstention leaves the request-stage decision standing; it never re-tests the
+  // static sample rate.
+  isResponseSampledIn(entry) {
+    const callback = this.config.sampleOnResponse;
+    if (!callback) {
+      return true;
+    }
+    const serverSpan = entry.endedServerSpan ?? entry.serverSpan;
+    let snapshot = serverSpan;
+    if (entry.record && Object.keys(entry.record.attributes).length > 0) {
+      const copy = copySpan(serverSpan);
+      copy.attributes = {
+        ...serverSpan.attributes,
+        ...entry.record.attributes
+      };
+      snapshot = copy;
+    }
+    const rate = resolveCallbackSampleRate(callback, snapshot, "sampleOnResponse");
+    if (rate === void 0) {
+      return true;
+    }
+    return isTraceSampledIn(serverSpan.spanContext().traceId, boundForSampleRate(rate));
+  }
+  dropRequestOnResponse(entry, record) {
+    entry.released = true;
+    entry.buffered = [];
+    record.dropReason = "sampled-out";
+    if (entry.record) {
+      entry.record.dropReason = "sampled-out";
+    }
+    this.removeCompletedRequestSpanIds(entry);
+    this.stash.delete(entry.serverSpanId);
+    this.onRequestFinished?.(entry.serverSpanId, false);
+  }
+  releaseIfComplete(entry) {
+    if (entry.released || !entry.transportCompleted || !entry.endedServerSpan) {
+      return;
+    }
+    this.releaseRequest(entry, entry.endedServerSpan);
+  }
+  // Descendants, the SERVER span, and logs enter downstream processing once, in
+  // that order. The exporter applies the request record and stash later.
+  releaseRequest(entry, serverSpan) {
+    entry.released = true;
+    for (const spanId of entry.spanIds) {
+      this.requests.delete(spanId);
+      this.addKeptSpanId(spanId, {
+        serverSpanId: entry.serverSpanId,
+        demoted: this.demotedSpanIds.delete(spanId)
+      });
+    }
+    for (const bufferedSpan of entry.buffered) {
+      this.downstream.onEnd(bufferedSpan);
+    }
+    entry.buffered = [];
+    const stash = this.stash.get(entry.serverSpanId);
+    this.stash.delete(entry.serverSpanId);
+    let exportSpan = serverSpan;
+    if (entry.record || stash || !serverSpan.ended) {
+      const copy = copySpan(serverSpan);
+      if (!serverSpan.ended) {
+        copy.endTime = (0, import_core.hrTime)();
+        copy.duration = (0, import_core.hrTimeDuration)(copy.startTime, copy.endTime);
+        copy.ended = true;
+      }
+      copy.apitallyData = { record: entry.record, stash };
+      exportSpan = copy;
+    }
+    this.downstream.onEnd(exportSpan);
+    this.onRequestFinished?.(entry.serverSpanId, true);
+  }
+  removeCompletedRequestSpanIds(entry) {
+    for (const spanId of entry.spanIds) {
+      this.requests.delete(spanId);
+      this.demotedSpanIds.delete(spanId);
+    }
+  }
+  addKeptSpanId(spanId, kept) {
+    if (this.keptSpanIds.size >= MAX_KEPT_SPAN_IDS) {
+      const oldestId = this.keptSpanIds.keys().next().value;
+      if (oldestId !== void 0) {
+        this.keptSpanIds.delete(oldestId);
+      }
+    }
+    this.keptSpanIds.set(spanId, kept);
+  }
+}
+function copySpan(span) {
+  const spanContext = span.spanContext();
+  return {
+    name: span.name,
+    kind: span.kind,
+    spanContext: () => spanContext,
+    parentSpanContext: span.parentSpanContext,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    status: span.status,
+    attributes: span.attributes,
+    links: span.links,
+    events: span.events,
+    duration: span.duration,
+    ended: span.ended,
+    resource: span.resource,
+    instrumentationScope: span.instrumentationScope,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
+}
+function resolveTransportDropReason(attributes) {
+  const method = attributes["http.request.method"] ?? attributes["http.method"];
+  if (method === "OPTIONS") {
+    return "method";
+  }
+  const scheme = attributes["url.scheme"] ?? attributes["http.scheme"];
+  return scheme === "ws" || scheme === "wss" ? "scheme" : void 0;
+}
+function writeUrlAttributesFromFullUrl(span) {
+  const attributes = span.attributes;
+  if (attributes["url.path"] !== void 0 || attributes["http.target"] !== void 0) {
+    return;
+  }
+  const url = attributes["url.full"] ?? attributes["http.url"];
+  if (typeof url !== "string") {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return;
+  }
+  const query = parsed.search.replace(/^\?/, "");
+  span.setAttribute("url.path", parsed.pathname);
+  if (query) {
+    span.setAttribute("url.query", query);
+  }
+  span.setAttribute("http.target", query ? `${parsed.pathname}?${query}` : parsed.pathname);
+}
+const TRACE_ID_LOW_64_BITS_MASK = (1n << 64n) - 1n;
+function boundForSampleRate(rate) {
+  return BigInt(Math.round(rate * 2 ** 64));
+}
+function isTraceSampledIn(traceId, bound) {
+  return (BigInt(`0x${traceId}`) & TRACE_ID_LOW_64_BITS_MASK) < bound;
+}
+function resolveCallbackSampleRate(callback, span, optionName) {
+  let result;
+  try {
+    result = callback(span);
+  } catch {
+    (0, import_logger.logWarning)(`The Apitally ${optionName} callback threw an error, so the request was captured`);
+    return 1;
+  }
+  if (result === void 0 || result === null) {
+    return void 0;
+  }
+  if (typeof result === "boolean") {
+    return result ? 1 : 0;
+  }
+  if (typeof result === "number" && result >= 0 && result <= 1) {
+    return result;
+  }
+  (0, import_logger.logWarning)(
+    `The Apitally ${optionName} callback returned an invalid value, so the request was captured. Sampling callbacks must synchronously return a number between 0 and 1, a boolean, or undefined.`
+  );
+  return 1;
+}
+function isContribPerMessageSpan(span) {
+  const scopeName = span.instrumentationScope?.name ?? "";
+  return span.kind === import_api.SpanKind.INTERNAL && [" http send", " http receive", " websocket send", " websocket receive"].some(
+    (suffix) => span.name.endsWith(suffix)
+  ) && (scopeName.startsWith("@opentelemetry/instrumentation") || scopeName.startsWith("opentelemetry.instrumentation."));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApitallySpanProcessor,
+  SpanPipeline,
+  copySpan,
+  getActiveSpanPipeline,
+  isApitallySpanProcessorDeclared,
+  resetSpanProcessorState,
+  setActiveSpanPipeline,
+  setServerSpanActivationCallback
+});
+//# sourceMappingURL=spanProcessor.cjs.map

package/dist/spanProcessor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spanProcessor.ts"],"sourcesContent":["import { type Attributes, type Context, SpanKind } from \"@opentelemetry/api\";\nimport { hrTime, hrTimeDuration } from \"@opentelemetry/core\";\nimport type { ReadableSpan, Span, SpanProcessor } from \"@opentelemetry/sdk-trace-base\";\nimport {\n  type ApitallyConfig,\n  compilePatterns,\n  DEFAULT_EXCLUDE_PATHS,\n  EXCLUDE_USER_AGENTS,\n  getConfig,\n  matchesAny,\n  type SamplingCallback,\n} from \"./config.js\";\nimport { writeConsumerAttributesFromContext } from \"./consumer.js\";\nimport {\n  REQUEST_RECORD_KEY,\n  type RequestDropReason,\n  type RequestRecord,\n  SPAN_HANDLE_KEY,\n  type SpanHandle,\n} from \"./context.js\";\nimport { logDebug, logWarning } from \"./logger.js\";\n\nconst MAX_BUFFERED_SPANS = 1_000;\nconst MAX_TRACKED_SPAN_IDS = MAX_BUFFERED_SPANS + 1;\nconst MAX_STASHED_REQUESTS = 2_048;\nconst MAX_KEPT_SPAN_IDS = 10_000;\nconst EXCLUDE_USER_AGENT_PATTERNS = compilePatterns(EXCLUDE_USER_AGENTS);\n\n// Transport-captured headers and bodies are attached only to Apitally's export\n// copy.\nexport interface RequestStash {\n  requestHeaders?: Record<string, string | string[]>;\n  requestBody?: Buffer;\n  responseHeaders?: Record<string, string | string[]>;\n  responseBody?: Buffer;\n}\n\nexport interface ApitallySpanData {\n  record?: RequestRecord;\n  stash?: RequestStash;\n  demoteToInternal?: boolean;\n}\n\n// Mutable ReadableSpan-shaped copy on Apitally's private export path; the span\n// handed to user-attached processors is never mutated.\nexport type SpanCopy = {\n  -readonly [Key in keyof ReadableSpan]: ReadableSpan[Key];\n} & { apitallyData?: ApitallySpanData };\n\n// The public processor delegates to the process-global pipeline. Construction\n// only declares that the application owns the tracer provider.\nexport class ApitallySpanProcessor implements SpanProcessor {\n  constructor() {\n    setApitallySpanProcessorDeclared();\n  }\n\n  onStart(span: Span, parentContext: Context): void {\n    let pipeline = getActiveSpanPipeline();\n    if (!pipeline && span.kind === SpanKind.SERVER) {\n      getServerSpanActivationCallback()?.(span);\n      pipeline = getActiveSpanPipeline();\n    }\n    pipeline?.onStart(span, parentContext);\n  }\n\n  onEnd(span: ReadableSpan): void {\n    getActiveSpanPipeline()?.onEnd(span);\n  }\n\n  // Flush failures resolve instead of rejecting into the user's provider.\n  forceFlush(): Promise<void> {\n    const pipeline = getActiveSpanPipeline();\n    if (!pipeline) {\n      return Promise.resolve();\n    }\n    return pipeline.forceFlush().catch((error: unknown) => {\n      logDebug(`Error flushing spans: ${String(error)}`);\n    });\n  }\n\n  // A user provider's shutdown only flushes released requests; SDK shutdown owns\n  // teardown.\n  shutdown(): Promise<void> {\n    return this.forceFlush();\n  }\n}\n\ntype ServerSpanActivationCallback = (span: Span) => void;\n\n// Symbol.for keys let ESM and CJS builds share processor coordination.\nconst ACTIVE_SPAN_PIPELINE_KEY = Symbol.for(\"apitally.activeSpanPipeline\");\nconst APITALLY_SPAN_PROCESSOR_DECLARED_KEY = Symbol.for(\"apitally.spanProcessorDeclared\");\nconst SERVER_SPAN_ACTIVATION_CALLBACK_KEY = Symbol.for(\"apitally.serverSpanActivationCallback\");\n\nexport function setActiveSpanPipeline(pipeline: SpanPipeline | undefined): void {\n  (globalThis as Record<symbol, SpanPipeline | undefined>)[ACTIVE_SPAN_PIPELINE_KEY] = pipeline;\n}\n\nexport function getActiveSpanPipeline(): SpanPipeline | undefined {\n  return (globalThis as Record<symbol, SpanPipeline | undefined>)[ACTIVE_SPAN_PIPELINE_KEY];\n}\n\nexport function setServerSpanActivationCallback(callback: ServerSpanActivationCallback): void {\n  const holder = globalThis as Record<symbol, ServerSpanActivationCallback | undefined>;\n  holder[SERVER_SPAN_ACTIVATION_CALLBACK_KEY] ??= callback;\n}\n\nexport function isApitallySpanProcessorDeclared(): boolean {\n  return (\n    (globalThis as Record<symbol, boolean | undefined>)[APITALLY_SPAN_PROCESSOR_DECLARED_KEY] ===\n    true\n  );\n}\n\nexport function resetSpanProcessorState(): void {\n  const holder = globalThis as Record<symbol, unknown>;\n  delete holder[ACTIVE_SPAN_PIPELINE_KEY];\n  delete holder[APITALLY_SPAN_PROCESSOR_DECLARED_KEY];\n  delete holder[SERVER_SPAN_ACTIVATION_CALLBACK_KEY];\n}\n\nfunction setApitallySpanProcessorDeclared(): void {\n  (globalThis as Record<symbol, boolean>)[APITALLY_SPAN_PROCESSOR_DECLARED_KEY] = true;\n}\n\nfunction getServerSpanActivationCallback(): ServerSpanActivationCallback | undefined {\n  return (globalThis as Record<symbol, ServerSpanActivationCallback | undefined>)[\n    SERVER_SPAN_ACTIVATION_CALLBACK_KEY\n  ];\n}\n\ninterface RequestEntry {\n  readonly serverSpanId: string;\n  readonly serverSpan: Span;\n  readonly spanIds: Set<string>;\n  record?: RequestRecord;\n  buffered: ReadableSpan[];\n  endedServerSpan?: ReadableSpan;\n  transportCompleted: boolean;\n  released: boolean;\n}\n\ninterface KeptSpanEntry {\n  readonly serverSpanId: string;\n  // Carries the demotion decision across release for spans that end late.\n  readonly demoted: boolean;\n}\n\n// Requests remain buffered until the SERVER span and transport complete, then\n// one keep/drop decision releases them once.\nexport class SpanPipeline implements SpanProcessor {\n  // Callbacks are optional because metrics and log pipelines start at activation.\n  metricsRecorder?: (record: RequestRecord) => void;\n  onRequestFinished?: (serverSpanId: string, kept: boolean) => void;\n  private readonly downstream: SpanProcessor;\n  private readonly config: ApitallyConfig;\n  private readonly sampleRateBound: bigint;\n  private readonly excludePathPatterns: RegExp[];\n  // Every span ID remains mapped to one request until completion so late logs\n  // resolve. A miss means dropped, completed, or non-request telemetry.\n  private readonly requests = new Map<string, RequestEntry>();\n  private readonly stash = new Map<string, RequestStash>();\n  private readonly demotedSpanIds = new Set<string>();\n  // Kept span IDs remain resolvable after release for late spans and logs; the\n  // oldest are evicted at the cap.\n  private readonly keptSpanIds = new Map<string, KeptSpanEntry>();\n\n  constructor(downstream: SpanProcessor) {\n    this.downstream = downstream;\n    this.config = getConfig();\n    this.sampleRateBound = boundForSampleRate(this.config.sampleRate);\n    this.excludePathPatterns = compilePatterns(DEFAULT_EXCLUDE_PATHS, this.config.excludePaths);\n  }\n\n  onStart(span: Span, parentContext: Context): void {\n    try {\n      if (isContribPerMessageSpan(span)) {\n        return;\n      }\n      const parent = span.parentSpanContext;\n      if (!parent || parent.isRemote) {\n        if (span.kind === SpanKind.SERVER) {\n          this.startRequest(span, parentContext);\n        }\n        return;\n      }\n      const entry = this.requests.get(parent.spanId);\n      const spanId = span.spanContext().spanId;\n      if (!entry) {\n        // A span started under a request already released as kept exports at\n        // its end, like the released request's other late telemetry.\n        const kept = this.keptSpanIds.get(parent.spanId);\n        if (kept) {\n          this.addKeptSpanId(spanId, {\n            serverSpanId: kept.serverSpanId,\n            demoted: false,\n          });\n        }\n        return;\n      }\n      if (entry.spanIds.size >= MAX_TRACKED_SPAN_IDS) {\n        logDebug(\"Apitally span tracking cap reached, dropping the span\");\n        return;\n      }\n      if (span.kind === SpanKind.SERVER) {\n        // A second middleware produced a SERVER span for this request. Apitally\n        // demotes its copy, but user exporters retain the duplicate.\n        this.demotedSpanIds.add(spanId);\n        logWarning(\n          `Detected a duplicate SERVER span produced by the instrumentation scope \"${span.instrumentationScope?.name ?? \"unknown\"}\" inside an active request. Apitally exports it as an INTERNAL span, but your own OpenTelemetry exporters still receive the duplicate. To resolve this, remove the middleware that produces it.`,\n        );\n      }\n      this.requests.set(spanId, entry);\n      entry.spanIds.add(spanId);\n    } catch (error) {\n      logWarning(`Error in the Apitally span processor: ${String(error)}`);\n    }\n  }\n\n  onEnd(span: ReadableSpan): void {\n    try {\n      const spanId = span.spanContext().spanId;\n      const isDemoted = this.demotedSpanIds.delete(spanId);\n      const entry = this.requests.get(spanId);\n      if (!entry) {\n        const kept = this.keptSpanIds.get(spanId);\n        if (kept) {\n          let exportSpan = span;\n          if (kept.demoted) {\n            const copy = copySpan(span);\n            copy.apitallyData = { demoteToInternal: true };\n            exportSpan = copy;\n          }\n          this.downstream.onEnd(exportSpan);\n        }\n        return;\n      }\n      if (spanId === entry.serverSpanId) {\n        entry.endedServerSpan = span;\n        this.releaseIfComplete(entry);\n        return;\n      }\n      // The span id stays mapped so log records emitted after this span ended\n      // still resolve to the request until it completes.\n      let exportSpan = span;\n      if (isDemoted) {\n        const copy = copySpan(span);\n        copy.apitallyData = { demoteToInternal: true };\n        exportSpan = copy;\n      }\n      if (entry.buffered.length < MAX_BUFFERED_SPANS) {\n        entry.buffered.push(exportSpan);\n      } else {\n        logDebug(\"Apitally span buffer cap reached, dropping the span\");\n      }\n    } catch (error) {\n      logWarning(`Error in the Apitally span processor: ${String(error)}`);\n    }\n  }\n\n  // Transport completion triggers response sampling and metrics independently\n  // of span-end timing. Map misses still record metrics and discard other data.\n  handleTransportCompletion(record: RequestRecord): void {\n    try {\n      record.dropReason = resolveTransportDropReason(record.attributes) ?? record.dropReason;\n      const entry =\n        record.serverSpanId !== undefined ? this.requests.get(record.serverSpanId) : undefined;\n      if (entry && !entry.transportCompleted && !entry.released) {\n        // The user-produced SERVER span started before the request record existed;\n        // attaching the record here carries transport attributes to the export copy.\n        entry.record ??= record;\n        entry.transportCompleted = true;\n        if (!this.isResponseSampledIn(entry)) {\n          this.dropRequestOnResponse(entry, record);\n        }\n      }\n      this.metricsRecorder?.(record);\n      if (entry) {\n        this.releaseIfComplete(entry);\n      }\n    } catch (error) {\n      logWarning(`Error in the Apitally span processor: ${String(error)}`);\n    }\n  }\n\n  // Holds captured headers and bodies until the exporter attaches them to the\n  // exported SERVER span copy. Fields already stashed are kept unless replaced.\n  updateStash(serverSpanId: string, update: RequestStash): void {\n    try {\n      // A request without an in-flight map entry can never release, so its\n      // stash entry would sit unconsumed until the cap evicts it.\n      if (!this.requests.has(serverSpanId)) {\n        return;\n      }\n      let entry = this.stash.get(serverSpanId);\n      if (!entry) {\n        if (this.stash.size >= MAX_STASHED_REQUESTS) {\n          const oldestKey = this.stash.keys().next().value;\n          if (oldestKey !== undefined) {\n            this.stash.delete(oldestKey);\n            logDebug(\"Apitally payload stash cap reached, dropping the oldest entry\");\n          }\n        }\n        entry = {};\n        this.stash.set(serverSpanId, entry);\n      }\n      if (update.requestHeaders !== undefined) {\n        entry.requestHeaders = update.requestHeaders;\n      }\n      if (update.requestBody !== undefined) {\n        entry.requestBody = update.requestBody;\n      }\n      if (update.responseHeaders !== undefined) {\n        entry.responseHeaders = update.responseHeaders;\n      }\n      if (update.responseBody !== undefined) {\n        entry.responseBody = update.responseBody;\n      }\n    } catch (error) {\n      logDebug(`Error updating the request stash: ${String(error)}`);\n    }\n  }\n\n  // Kept requests remain resolvable after release so late logs retain their\n  // request association.\n  resolveServerSpanId(spanId: string): string | undefined {\n    return this.requests.get(spanId)?.serverSpanId ?? this.keptSpanIds.get(spanId)?.serverSpanId;\n  }\n\n  isRequestInFlight(serverSpanId: string): boolean {\n    return this.requests.has(serverSpanId);\n  }\n\n  // Exclusion answers \"never wanted\" and runs strictly before sampling; an\n  // excluded request never invokes a user sampling callback.\n  resolveRequestDropReasonBeforeSampling(attributes: Attributes): RequestDropReason | undefined {\n    const transportDropReason = resolveTransportDropReason(attributes);\n    if (transportDropReason !== undefined) {\n      return transportDropReason;\n    }\n    const path = attributes[\"url.path\"] ?? attributes[\"http.target\"];\n    if (typeof path === \"string\" && matchesAny(this.excludePathPatterns, path.split(\"?\")[0])) {\n      return \"excluded\";\n    }\n    const userAgent = attributes[\"user_agent.original\"] ?? attributes[\"http.user_agent\"];\n    if (typeof userAgent === \"string\" && matchesAny(EXCLUDE_USER_AGENT_PATTERNS, userAgent)) {\n      return \"excluded\";\n    }\n    return undefined;\n  }\n\n  forceFlush(): Promise<void> {\n    return this.downstream.forceFlush();\n  }\n\n  // Shutdown releases requests with completed transport observation once and\n  // discards incomplete requests, which cannot complete afterward.\n  async shutdown(): Promise<void> {\n    try {\n      for (const entry of new Set(this.requests.values())) {\n        if (!entry.released && entry.transportCompleted) {\n          this.releaseRequest(entry, entry.endedServerSpan ?? entry.serverSpan);\n        }\n      }\n      this.requests.clear();\n      this.stash.clear();\n      this.demotedSpanIds.clear();\n      this.keptSpanIds.clear();\n    } catch (error) {\n      logWarning(`Error in the Apitally span processor: ${String(error)}`);\n    }\n    await this.downstream.shutdown();\n  }\n\n  private startRequest(span: Span, parentContext: Context): void {\n    const spanId = span.spanContext().spanId;\n    // The handle is filled for every local-root SERVER span, independent of the\n    // keep decision, so runtime writes always reach the current request's span.\n    const handle = parentContext.getValue(SPAN_HANDLE_KEY) as SpanHandle | undefined;\n    if (handle) {\n      handle.span = span;\n    }\n    const record = parentContext.getValue(REQUEST_RECORD_KEY) as RequestRecord | undefined;\n    if (record) {\n      record.serverSpanId = spanId;\n    }\n    writeConsumerAttributesFromContext(parentContext, span, record);\n    writeUrlAttributesFromFullUrl(span);\n    const dropReason =\n      this.resolveRequestDropReasonBeforeSampling(span.attributes) ??\n      (this.isRequestSampledIn(span) ? undefined : \"sampled-out\");\n    if (dropReason) {\n      if (record) {\n        record.dropReason = dropReason;\n      }\n      return;\n    }\n    this.requests.set(spanId, {\n      serverSpanId: spanId,\n      serverSpan: span,\n      spanIds: new Set([spanId]),\n      record,\n      buffered: [],\n      transportCompleted: false,\n      released: false,\n    });\n  }\n\n  private isRequestSampledIn(span: Span): boolean {\n    const callback = this.config.sampleOnRequest;\n    const rate = callback\n      ? resolveCallbackSampleRate(callback, span, \"sampleOnRequest\")\n      : undefined;\n    const bound = rate === undefined ? this.sampleRateBound : boundForSampleRate(rate);\n    return isTraceSampledIn(span.spanContext().traceId, bound);\n  }\n\n  // Abstention leaves the request-stage decision standing; it never re-tests the\n  // static sample rate.\n  private isResponseSampledIn(entry: RequestEntry): boolean {\n    const callback = this.config.sampleOnResponse;\n    if (!callback) {\n      return true;\n    }\n    const serverSpan = entry.endedServerSpan ?? entry.serverSpan;\n    let snapshot: ReadableSpan = serverSpan;\n    if (entry.record && Object.keys(entry.record.attributes).length > 0) {\n      // The callback sees transport-observed values even when they were learned\n      // after the span ended (final route, response size).\n      const copy = copySpan(serverSpan);\n      copy.attributes = {\n        ...serverSpan.attributes,\n        ...entry.record.attributes,\n      };\n      snapshot = copy;\n    }\n    const rate = resolveCallbackSampleRate(callback, snapshot, \"sampleOnResponse\");\n    if (rate === undefined) {\n      return true;\n    }\n    return isTraceSampledIn(serverSpan.spanContext().traceId, boundForSampleRate(rate));\n  }\n\n  private dropRequestOnResponse(entry: RequestEntry, record: RequestRecord): void {\n    // Removing every span id sends the dropped request's late telemetry to the\n    // lookup-miss rule, so it is discarded locally.\n    entry.released = true;\n    entry.buffered = [];\n    record.dropReason = \"sampled-out\";\n    if (entry.record) {\n      entry.record.dropReason = \"sampled-out\";\n    }\n    this.removeCompletedRequestSpanIds(entry);\n    this.stash.delete(entry.serverSpanId);\n    this.onRequestFinished?.(entry.serverSpanId, false);\n  }\n\n  private releaseIfComplete(entry: RequestEntry): void {\n    if (entry.released || !entry.transportCompleted || !entry.endedServerSpan) {\n      return;\n    }\n    this.releaseRequest(entry, entry.endedServerSpan);\n  }\n\n  // Descendants, the SERVER span, and logs enter downstream processing once, in\n  // that order. The exporter applies the request record and stash later.\n  private releaseRequest(entry: RequestEntry, serverSpan: ReadableSpan): void {\n    entry.released = true;\n    for (const spanId of entry.spanIds) {\n      this.requests.delete(spanId);\n      this.addKeptSpanId(spanId, {\n        serverSpanId: entry.serverSpanId,\n        demoted: this.demotedSpanIds.delete(spanId),\n      });\n    }\n    for (const bufferedSpan of entry.buffered) {\n      this.downstream.onEnd(bufferedSpan);\n    }\n    entry.buffered = [];\n    const stash = this.stash.get(entry.serverSpanId);\n    this.stash.delete(entry.serverSpanId);\n    let exportSpan = serverSpan;\n    if (entry.record || stash || !serverSpan.ended) {\n      const copy = copySpan(serverSpan);\n      if (!serverSpan.ended) {\n        // A SERVER span released during shutdown uses shutdown as its end time.\n        copy.endTime = hrTime();\n        copy.duration = hrTimeDuration(copy.startTime, copy.endTime);\n        copy.ended = true;\n      }\n      copy.apitallyData = { record: entry.record, stash };\n      exportSpan = copy;\n    }\n    this.downstream.onEnd(exportSpan);\n    this.onRequestFinished?.(entry.serverSpanId, true);\n  }\n\n  private removeCompletedRequestSpanIds(entry: RequestEntry): void {\n    for (const spanId of entry.spanIds) {\n      this.requests.delete(spanId);\n      this.demotedSpanIds.delete(spanId);\n    }\n  }\n\n  private addKeptSpanId(spanId: string, kept: KeptSpanEntry): void {\n    if (this.keptSpanIds.size >= MAX_KEPT_SPAN_IDS) {\n      const oldestId = this.keptSpanIds.keys().next().value;\n      if (oldestId !== undefined) {\n        this.keptSpanIds.delete(oldestId);\n      }\n    }\n    this.keptSpanIds.set(spanId, kept);\n  }\n}\n\nexport function copySpan(span: ReadableSpan): SpanCopy {\n  const spanContext = span.spanContext();\n  return {\n    name: span.name,\n    kind: span.kind,\n    spanContext: () => spanContext,\n    parentSpanContext: span.parentSpanContext,\n    startTime: span.startTime,\n    endTime: span.endTime,\n    status: span.status,\n    attributes: span.attributes,\n    links: span.links,\n    events: span.events,\n    duration: span.duration,\n    ended: span.ended,\n    resource: span.resource,\n    instrumentationScope: span.instrumentationScope,\n    droppedAttributesCount: span.droppedAttributesCount,\n    droppedEventsCount: span.droppedEventsCount,\n    droppedLinksCount: span.droppedLinksCount,\n  };\n}\n\nfunction resolveTransportDropReason(attributes: Attributes): RequestDropReason | undefined {\n  const method = attributes[\"http.request.method\"] ?? attributes[\"http.method\"];\n  if (method === \"OPTIONS\") {\n    return \"method\";\n  }\n  const scheme = attributes[\"url.scheme\"] ?? attributes[\"http.scheme\"];\n  return scheme === \"ws\" || scheme === \"wss\" ? \"scheme\" : undefined;\n}\n\n// Missing path, query, and target attributes are derived from the full URL\n// because exclusion, display, and redaction require them.\nfunction writeUrlAttributesFromFullUrl(span: Span): void {\n  const attributes = span.attributes;\n  if (attributes[\"url.path\"] !== undefined || attributes[\"http.target\"] !== undefined) {\n    return;\n  }\n  const url = attributes[\"url.full\"] ?? attributes[\"http.url\"];\n  if (typeof url !== \"string\") {\n    return;\n  }\n  let parsed: URL;\n  try {\n    parsed = new URL(url);\n  } catch {\n    return;\n  }\n  const query = parsed.search.replace(/^\\?/, \"\");\n  span.setAttribute(\"url.path\", parsed.pathname);\n  if (query) {\n    span.setAttribute(\"url.query\", query);\n  }\n  span.setAttribute(\"http.target\", query ? `${parsed.pathname}?${query}` : parsed.pathname);\n}\n\nconst TRACE_ID_LOW_64_BITS_MASK = (1n << 64n) - 1n;\n\nfunction boundForSampleRate(rate: number): bigint {\n  return BigInt(Math.round(rate * 2 ** 64));\n}\n\n// Low 64-bit ratio sampling is deterministic per trace. Comparing the same\n// value at both stages makes the lower rate decisive.\nfunction isTraceSampledIn(traceId: string, bound: bigint): boolean {\n  return (BigInt(`0x${traceId}`) & TRACE_ID_LOW_64_BITS_MASK) < bound;\n}\n\n// A throwing or invalid-returning callback resolves to keep: a user bug must\n// never lose data without a warning. Undefined means the callback abstained.\nfunction resolveCallbackSampleRate(\n  callback: SamplingCallback,\n  span: ReadableSpan,\n  optionName: string,\n): number | undefined {\n  let result: unknown;\n  try {\n    result = callback(span);\n  } catch {\n    logWarning(`The Apitally ${optionName} callback threw an error, so the request was captured`);\n    return 1;\n  }\n  if (result === undefined || result === null) {\n    return undefined;\n  }\n  if (typeof result === \"boolean\") {\n    return result ? 1 : 0;\n  }\n  if (typeof result === \"number\" && result >= 0 && result <= 1) {\n    return result;\n  }\n  logWarning(\n    `The Apitally ${optionName} callback returned an invalid value, so the request was captured. Sampling callbacks must synchronously return a number between 0 and 1, a boolean, or undefined.`,\n  );\n  return 1;\n}\n\nfunction isContribPerMessageSpan(span: Span): boolean {\n  const scopeName = span.instrumentationScope?.name ?? \"\";\n  return (\n    span.kind === SpanKind.INTERNAL &&\n    [\" http send\", \" http receive\", \" websocket send\", \" websocket receive\"].some((suffix) =>\n      span.name.endsWith(suffix),\n    ) &&\n    (scopeName.startsWith(\"@opentelemetry/instrumentation\") ||\n      scopeName.startsWith(\"opentelemetry.instrumentation.\"))\n  );\n}\n"],"mappings":"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","names":["exportSpan"]}

package/dist/spanProcessor.d.cts

@@ -0,0 +1,67 @@
+import { Context, Attributes } from '@opentelemetry/api';
+import { SpanProcessor, Span, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { RequestRecord, RequestDropReason } from './context.cjs';
+import '@opentelemetry/core';
+
+interface RequestStash {
+    requestHeaders?: Record<string, string | string[]>;
+    requestBody?: Buffer;
+    responseHeaders?: Record<string, string | string[]>;
+    responseBody?: Buffer;
+}
+interface ApitallySpanData {
+    record?: RequestRecord;
+    stash?: RequestStash;
+    demoteToInternal?: boolean;
+}
+type SpanCopy = {
+    -readonly [Key in keyof ReadableSpan]: ReadableSpan[Key];
+} & {
+    apitallyData?: ApitallySpanData;
+};
+declare class ApitallySpanProcessor implements SpanProcessor {
+    constructor();
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+type ServerSpanActivationCallback = (span: Span) => void;
+declare function setActiveSpanPipeline(pipeline: SpanPipeline | undefined): void;
+declare function getActiveSpanPipeline(): SpanPipeline | undefined;
+declare function setServerSpanActivationCallback(callback: ServerSpanActivationCallback): void;
+declare function isApitallySpanProcessorDeclared(): boolean;
+declare function resetSpanProcessorState(): void;
+declare class SpanPipeline implements SpanProcessor {
+    metricsRecorder?: (record: RequestRecord) => void;
+    onRequestFinished?: (serverSpanId: string, kept: boolean) => void;
+    private readonly downstream;
+    private readonly config;
+    private readonly sampleRateBound;
+    private readonly excludePathPatterns;
+    private readonly requests;
+    private readonly stash;
+    private readonly demotedSpanIds;
+    private readonly keptSpanIds;
+    constructor(downstream: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    handleTransportCompletion(record: RequestRecord): void;
+    updateStash(serverSpanId: string, update: RequestStash): void;
+    resolveServerSpanId(spanId: string): string | undefined;
+    isRequestInFlight(serverSpanId: string): boolean;
+    resolveRequestDropReasonBeforeSampling(attributes: Attributes): RequestDropReason | undefined;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private startRequest;
+    private isRequestSampledIn;
+    private isResponseSampledIn;
+    private dropRequestOnResponse;
+    private releaseIfComplete;
+    private releaseRequest;
+    private removeCompletedRequestSpanIds;
+    private addKeptSpanId;
+}
+declare function copySpan(span: ReadableSpan): SpanCopy;
+
+export { type ApitallySpanData, ApitallySpanProcessor, type RequestStash, type SpanCopy, SpanPipeline, copySpan, getActiveSpanPipeline, isApitallySpanProcessorDeclared, resetSpanProcessorState, setActiveSpanPipeline, setServerSpanActivationCallback };