@tracewayapp/backend 0.2.0

package/dist/index.js

@@ -0,0 +1,742 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CollectionFrameStore: () => CollectionFrameStore,
+  addSpanToContext: () => addSpanToContext,
+  captureCurrentTrace: () => captureCurrentTrace,
+  captureException: () => captureException,
+  captureExceptionWithAttributes: () => captureExceptionWithAttributes,
+  captureMessage: () => captureMessage,
+  captureMetric: () => captureMetric,
+  captureTask: () => captureTask,
+  captureTrace: () => captureTrace,
+  collectMetrics: () => collectMetrics,
+  endSpan: () => endSpan,
+  forkTraceContext: () => forkTraceContext,
+  formatErrorStackTrace: () => formatErrorStackTrace,
+  getTraceContext: () => getTraceContext,
+  getTraceDuration: () => getTraceDuration,
+  getTraceId: () => getTraceId,
+  getTraceSpans: () => getTraceSpans,
+  hasTraceContext: () => hasTraceContext,
+  init: () => init,
+  measureTask: () => measureTask,
+  resetCpuTracking: () => resetCpuTracking,
+  runWithTraceContext: () => runWithTraceContext,
+  setTraceAttribute: () => setTraceAttribute,
+  setTraceAttributes: () => setTraceAttributes,
+  setTraceResponseInfo: () => setTraceResponseInfo,
+  shouldSample: () => shouldSample,
+  shutdown: () => shutdown,
+  startSpan: () => startSpan,
+  traceContextStorage: () => asyncLocalStorage,
+  withTraceContext: () => withTraceContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/traceway.ts
+var import_core4 = require("@tracewayapp/core");
+
+// src/collection-frame-store.ts
+var zlib = __toESM(require("zlib"));
+
+// src/typed-ring.ts
+var TypedRing = class {
+  arr;
+  head = 0;
+  _capacity;
+  _len = 0;
+  constructor(capacity) {
+    this._capacity = capacity;
+    this.arr = new Array(capacity).fill(null);
+  }
+  get length() {
+    return this._len;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+  push(val) {
+    this.arr[this.head] = val;
+    this.head = (this.head + 1) % this._capacity;
+    if (this._len < this._capacity) {
+      this._len += 1;
+    }
+  }
+  readAll() {
+    const result = [];
+    for (let i = 0; i < this._len; i++) {
+      const idx = (this.head - this._len + i + this._capacity) % this._capacity;
+      result.push(this.arr[idx]);
+    }
+    return result;
+  }
+  clear() {
+    for (let i = 0; i < this.arr.length; i++) {
+      this.arr[i] = null;
+    }
+    this.head = 0;
+    this._len = 0;
+  }
+  remove(vals) {
+    if (vals.length === 0) return 0;
+    const toRemove = new Set(vals);
+    let writeIdx = 0;
+    let removed = 0;
+    for (let i = 0; i < this._len; i++) {
+      const readIdx = (this.head - this._len + i + this._capacity) % this._capacity;
+      if (toRemove.has(this.arr[readIdx])) {
+        removed++;
+      } else {
+        if (writeIdx !== i) {
+          const destIdx = (this.head - this._len + writeIdx + this._capacity) % this._capacity;
+          this.arr[destIdx] = this.arr[readIdx];
+        }
+        writeIdx++;
+      }
+    }
+    for (let i = writeIdx; i < this._len; i++) {
+      const idx = (this.head - this._len + i + this._capacity) % this._capacity;
+      this.arr[idx] = null;
+    }
+    this._len = writeIdx;
+    this.head = (this.head - removed + this._capacity) % this._capacity;
+    return removed;
+  }
+};
+
+// src/metrics.ts
+var os = __toESM(require("os"));
+var import_core = require("@tracewayapp/core");
+var import_core2 = require("@tracewayapp/core");
+var prevCpuUsage = null;
+var prevCpuTime = null;
+function collectMetrics() {
+  const metrics = [];
+  const recordedAt = (0, import_core2.nowISO)();
+  const mem = process.memoryUsage();
+  metrics.push({
+    name: import_core.METRIC_MEM_USED,
+    value: Math.round(mem.rss / 1024 / 1024 * 100) / 100,
+    recordedAt
+  });
+  const totalMem = os.totalmem();
+  metrics.push({
+    name: import_core.METRIC_MEM_TOTAL,
+    value: Math.round(totalMem / 1024 / 1024 * 100) / 100,
+    recordedAt
+  });
+  const currentCpuUsage = process.cpuUsage();
+  const currentTime = Date.now();
+  if (prevCpuUsage !== null && prevCpuTime !== null) {
+    const elapsedMs = currentTime - prevCpuTime;
+    if (elapsedMs > 0) {
+      const userDelta = currentCpuUsage.user - prevCpuUsage.user;
+      const systemDelta = currentCpuUsage.system - prevCpuUsage.system;
+      const totalDeltaMs = (userDelta + systemDelta) / 1e3;
+      const cpuCount = os.cpus().length || 1;
+      const cpuPercent = totalDeltaMs / elapsedMs / cpuCount * 100;
+      metrics.push({
+        name: import_core.METRIC_CPU_USED_PCNT,
+        value: Math.round(cpuPercent * 100) / 100,
+        recordedAt
+      });
+    }
+  }
+  prevCpuUsage = currentCpuUsage;
+  prevCpuTime = currentTime;
+  return metrics;
+}
+function resetCpuTracking() {
+  prevCpuUsage = null;
+  prevCpuTime = null;
+}
+
+// src/collection-frame-store.ts
+var CollectionFrameStore = class {
+  current = null;
+  currentSetAt = Date.now();
+  sendQueue;
+  lastUploadStarted = null;
+  collectionTimer = null;
+  metricsTimer = null;
+  apiUrl;
+  token;
+  debug;
+  collectionInterval;
+  uploadThrottle;
+  metricsInterval;
+  version;
+  serverName;
+  sampleRate;
+  errorSampleRate;
+  constructor(options) {
+    this.apiUrl = options.apiUrl;
+    this.token = options.token;
+    this.debug = options.debug;
+    this.collectionInterval = options.collectionInterval;
+    this.uploadThrottle = options.uploadThrottle;
+    this.metricsInterval = options.metricsInterval;
+    this.version = options.version;
+    this.serverName = options.serverName;
+    this.sampleRate = options.sampleRate;
+    this.errorSampleRate = options.errorSampleRate;
+    this.sendQueue = new TypedRing(
+      options.maxCollectionFrames
+    );
+    this.collectionTimer = setInterval(() => {
+      this.tick();
+    }, this.collectionInterval);
+    if (this.collectionTimer && typeof this.collectionTimer.unref === "function") {
+      this.collectionTimer.unref();
+    }
+    this.metricsTimer = setInterval(() => {
+      this.collectSystemMetrics();
+    }, this.metricsInterval);
+    if (this.metricsTimer && typeof this.metricsTimer.unref === "function") {
+      this.metricsTimer.unref();
+    }
+  }
+  tick() {
+    if (this.current !== null) {
+      if (this.currentSetAt < Date.now() - this.collectionInterval) {
+        this.rotateCurrentCollectionFrame();
+        this.processSendQueue();
+      }
+    } else if (this.sendQueue.length > 0) {
+      this.processSendQueue();
+    }
+  }
+  ensureCurrent() {
+    if (this.current === null) {
+      this.current = { stackTraces: [], metrics: [], traces: [] };
+      this.currentSetAt = Date.now();
+    }
+    return this.current;
+  }
+  addException(exception) {
+    this.ensureCurrent().stackTraces.push(exception);
+  }
+  addMetric(metric) {
+    this.ensureCurrent().metrics.push(metric);
+  }
+  addTrace(trace) {
+    this.ensureCurrent().traces.push(trace);
+  }
+  rotateCurrentCollectionFrame() {
+    if (this.current !== null) {
+      this.sendQueue.push(this.current);
+      this.current = null;
+    }
+  }
+  processSendQueue() {
+    if (this.lastUploadStarted === null || this.lastUploadStarted < Date.now() - this.uploadThrottle) {
+      this.lastUploadStarted = Date.now();
+      const frames = this.sendQueue.readAll();
+      if (frames.length > 0) {
+        this.triggerUpload(frames);
+      }
+    }
+  }
+  triggerUpload(framesToSend) {
+    const payload = {
+      collectionFrames: framesToSend,
+      appVersion: this.version,
+      serverName: this.serverName
+    };
+    let jsonData;
+    try {
+      jsonData = JSON.stringify(payload);
+    } catch (err) {
+      if (this.debug) {
+        console.error("Traceway: failed to serialize frames:", err);
+      }
+      return;
+    }
+    let gzipped;
+    try {
+      gzipped = new Uint8Array(zlib.gzipSync(Buffer.from(jsonData)));
+    } catch (err) {
+      if (this.debug) {
+        console.error("Traceway: failed to gzip:", err);
+      }
+      return;
+    }
+    fetch(this.apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Encoding": "gzip",
+        Authorization: `Bearer ${this.token}`
+      },
+      body: gzipped
+    }).then((resp) => {
+      if (resp.status === 200) {
+        this.sendQueue.remove(framesToSend);
+      } else if (this.debug) {
+        console.error(`Traceway: upload returned status ${resp.status}`);
+      }
+    }).catch((err) => {
+      if (this.debug) {
+        console.error("Traceway: upload failed:", err);
+      }
+    });
+  }
+  collectSystemMetrics() {
+    try {
+      const metrics = collectMetrics();
+      for (const metric of metrics) {
+        this.addMetric(metric);
+      }
+    } catch (err) {
+      if (this.debug) {
+        console.error("Traceway: failed to collect metrics:", err);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.collectionTimer !== null) {
+      clearInterval(this.collectionTimer);
+      this.collectionTimer = null;
+    }
+    if (this.metricsTimer !== null) {
+      clearInterval(this.metricsTimer);
+      this.metricsTimer = null;
+    }
+    this.rotateCurrentCollectionFrame();
+    const frames = this.sendQueue.readAll();
+    if (frames.length === 0) return;
+    const payload = {
+      collectionFrames: frames,
+      appVersion: this.version,
+      serverName: this.serverName
+    };
+    try {
+      const jsonData = JSON.stringify(payload);
+      const gzipped = new Uint8Array(zlib.gzipSync(Buffer.from(jsonData)));
+      const resp = await fetch(this.apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Encoding": "gzip",
+          Authorization: `Bearer ${this.token}`
+        },
+        body: gzipped
+      });
+      if (resp.status === 200) {
+        this.sendQueue.remove(frames);
+      }
+    } catch (err) {
+      if (this.debug) {
+        console.error("Traceway: shutdown upload failed:", err);
+      }
+    }
+  }
+};
+
+// src/stack-trace.ts
+function formatErrorStackTrace(error) {
+  const lines = [];
+  const typeName = error.constructor.name || "Error";
+  lines.push(`${typeName}: ${error.message}`);
+  if (error.stack) {
+    const stackLines = error.stack.split("\n");
+    for (const line of stackLines) {
+      const match = line.match(/^\s+at\s+(.+?)\s+\((.+):(\d+):\d+\)$/);
+      if (match) {
+        const funcName = shortenFunctionName(match[1]);
+        const file = shortenFilePath(match[2]);
+        const lineNum = match[3];
+        lines.push(`${funcName}()`);
+        lines.push(`    ${file}:${lineNum}`);
+        continue;
+      }
+      const matchNoParens = line.match(/^\s+at\s+(.+):(\d+):\d+$/);
+      if (matchNoParens) {
+        const file = shortenFilePath(matchNoParens[1]);
+        const lineNum = matchNoParens[2];
+        lines.push(`<anonymous>()`);
+        lines.push(`    ${file}:${lineNum}`);
+        continue;
+      }
+      const matchFnOnly = line.match(/^\s+at\s+(.+)$/);
+      if (matchFnOnly) {
+        const funcName = shortenFunctionName(matchFnOnly[1]);
+        lines.push(`${funcName}()`);
+        lines.push(`    <unknown>:0`);
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function shortenFunctionName(fn) {
+  const slashIdx = fn.lastIndexOf("/");
+  if (slashIdx >= 0) {
+    fn = fn.slice(slashIdx + 1);
+  }
+  const dotIdx = fn.indexOf(".");
+  if (dotIdx >= 0) {
+    fn = fn.slice(dotIdx + 1);
+  }
+  return fn;
+}
+function shortenFilePath(filePath) {
+  const parts = filePath.split("/");
+  return parts[parts.length - 1];
+}
+
+// src/context.ts
+var import_async_hooks = require("async_hooks");
+var import_core3 = require("@tracewayapp/core");
+var asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+function getTraceContext() {
+  return asyncLocalStorage.getStore();
+}
+function getTraceId() {
+  return asyncLocalStorage.getStore()?.traceId;
+}
+function hasTraceContext() {
+  return asyncLocalStorage.getStore() !== void 0;
+}
+function withTraceContext(options, fn) {
+  const context = {
+    traceId: options.traceId ?? (0, import_core3.generateUUID)(),
+    isTask: options.isTask ?? false,
+    startedAt: /* @__PURE__ */ new Date(),
+    spans: [],
+    attributes: options.attributes ?? {},
+    endpoint: options.endpoint,
+    clientIP: options.clientIP
+  };
+  return asyncLocalStorage.run(context, fn);
+}
+function runWithTraceContext(options, fn) {
+  return withTraceContext(options, fn);
+}
+function addSpanToContext(span) {
+  const ctx = asyncLocalStorage.getStore();
+  if (ctx) {
+    ctx.spans.push(span);
+  }
+}
+function setTraceAttribute(key, value) {
+  const ctx = asyncLocalStorage.getStore();
+  if (ctx) {
+    ctx.attributes[key] = value;
+  }
+}
+function setTraceAttributes(attributes) {
+  const ctx = asyncLocalStorage.getStore();
+  if (ctx) {
+    Object.assign(ctx.attributes, attributes);
+  }
+}
+function setTraceResponseInfo(statusCode, bodySize) {
+  const ctx = asyncLocalStorage.getStore();
+  if (ctx) {
+    ctx.statusCode = statusCode;
+    ctx.bodySize = bodySize;
+  }
+}
+function getTraceSpans() {
+  return asyncLocalStorage.getStore()?.spans ?? [];
+}
+function getTraceDuration() {
+  const ctx = asyncLocalStorage.getStore();
+  if (!ctx) return 0;
+  return Date.now() - ctx.startedAt.getTime();
+}
+function forkTraceContext(fn) {
+  const parentCtx = asyncLocalStorage.getStore();
+  if (!parentCtx) return void 0;
+  const forkedContext = {
+    ...parentCtx,
+    spans: [],
+    // Forked context gets its own spans
+    attributes: { ...parentCtx.attributes }
+  };
+  return asyncLocalStorage.run(forkedContext, () => {
+    const result = fn();
+    parentCtx.spans.push(...forkedContext.spans);
+    return result;
+  });
+}
+
+// src/traceway.ts
+var os2 = __toESM(require("os"));
+var store = null;
+function getHostname() {
+  try {
+    const hostname2 = os2.hostname();
+    const dotIdx = hostname2.indexOf(".");
+    return dotIdx >= 0 ? hostname2.slice(0, dotIdx) : hostname2;
+  } catch {
+    return "unknown";
+  }
+}
+function init(connectionString, options = {}) {
+  if (store !== null) {
+    throw new Error("Traceway: already initialized. Call shutdown() first.");
+  }
+  const { token, apiUrl } = (0, import_core4.parseConnectionString)(connectionString);
+  store = new CollectionFrameStore({
+    apiUrl,
+    token,
+    debug: options.debug ?? false,
+    maxCollectionFrames: options.maxCollectionFrames ?? 12,
+    collectionInterval: options.collectionInterval ?? 5e3,
+    uploadThrottle: options.uploadThrottle ?? 2e3,
+    metricsInterval: options.metricsInterval ?? 3e4,
+    version: options.version ?? "",
+    serverName: options.serverName ?? getHostname(),
+    sampleRate: options.sampleRate ?? 1,
+    errorSampleRate: options.errorSampleRate ?? 1
+  });
+}
+function captureException(error) {
+  if (!store) return;
+  const ctx = getTraceContext();
+  captureExceptionWithAttributes(
+    error,
+    ctx?.attributes,
+    ctx?.traceId
+  );
+}
+function captureExceptionWithAttributes(error, attributes, traceId) {
+  if (!store) return;
+  const ctx = getTraceContext();
+  const resolvedTraceId = traceId ?? ctx?.traceId ?? null;
+  const resolvedAttrs = attributes ?? ctx?.attributes;
+  const isTask = ctx?.isTask ?? false;
+  store.addException({
+    traceId: resolvedTraceId,
+    isTask: isTask || void 0,
+    stackTrace: formatErrorStackTrace(error),
+    recordedAt: (0, import_core4.nowISO)(),
+    attributes: resolvedAttrs,
+    isMessage: false
+  });
+}
+function captureMessage(msg, attributes) {
+  if (!store) return;
+  const ctx = getTraceContext();
+  const resolvedTraceId = ctx?.traceId ?? null;
+  const resolvedAttrs = attributes ?? ctx?.attributes;
+  const isTask = ctx?.isTask ?? false;
+  store.addException({
+    traceId: resolvedTraceId,
+    isTask: isTask || void 0,
+    stackTrace: msg,
+    recordedAt: (0, import_core4.nowISO)(),
+    attributes: resolvedAttrs,
+    isMessage: true
+  });
+}
+function captureMetric(name, value) {
+  if (!store) return;
+  store.addMetric({
+    name,
+    value,
+    recordedAt: (0, import_core4.nowISO)()
+  });
+}
+function captureTrace(traceId, endpoint, durationMs, startedAt, statusCode, bodySize, clientIP, attributes, spans) {
+  if (!store) return;
+  store.addTrace({
+    id: traceId,
+    endpoint,
+    duration: (0, import_core4.msToNanoseconds)(durationMs),
+    recordedAt: startedAt.toISOString(),
+    statusCode,
+    bodySize,
+    clientIP,
+    attributes,
+    spans
+  });
+}
+function captureTask(traceId, taskName, durationMs, startedAt, attributes, spans) {
+  if (!store) return;
+  store.addTrace({
+    id: traceId,
+    endpoint: taskName,
+    duration: (0, import_core4.msToNanoseconds)(durationMs),
+    recordedAt: startedAt.toISOString(),
+    statusCode: 0,
+    bodySize: 0,
+    clientIP: "",
+    attributes,
+    spans,
+    isTask: true
+  });
+}
+function startSpan(name) {
+  const now = Date.now();
+  return {
+    id: (0, import_core4.generateUUID)(),
+    name,
+    startTime: new Date(now).toISOString(),
+    startedAt: now
+  };
+}
+function endSpan(span, addToContext = true) {
+  const durationMs = Date.now() - span.startedAt;
+  const completedSpan = {
+    id: span.id,
+    name: span.name,
+    startTime: span.startTime,
+    duration: (0, import_core4.msToNanoseconds)(durationMs)
+  };
+  if (addToContext) {
+    addSpanToContext(completedSpan);
+  }
+  return completedSpan;
+}
+function captureCurrentTrace() {
+  if (!store) return;
+  const ctx = getTraceContext();
+  if (!ctx) return;
+  const durationMs = Date.now() - ctx.startedAt.getTime();
+  const isError = (ctx.statusCode ?? 0) >= 500;
+  if (!shouldSample(isError)) return;
+  if (ctx.isTask) {
+    store.addTrace({
+      id: ctx.traceId,
+      endpoint: ctx.endpoint ?? "unknown-task",
+      duration: (0, import_core4.msToNanoseconds)(durationMs),
+      recordedAt: ctx.startedAt.toISOString(),
+      statusCode: 0,
+      bodySize: 0,
+      clientIP: "",
+      attributes: Object.keys(ctx.attributes).length > 0 ? ctx.attributes : void 0,
+      spans: ctx.spans.length > 0 ? ctx.spans : void 0,
+      isTask: true
+    });
+  } else {
+    store.addTrace({
+      id: ctx.traceId,
+      endpoint: ctx.endpoint ?? "unknown",
+      duration: (0, import_core4.msToNanoseconds)(durationMs),
+      recordedAt: ctx.startedAt.toISOString(),
+      statusCode: ctx.statusCode ?? 0,
+      bodySize: ctx.bodySize ?? 0,
+      clientIP: ctx.clientIP ?? "",
+      attributes: Object.keys(ctx.attributes).length > 0 ? ctx.attributes : void 0,
+      spans: ctx.spans.length > 0 ? ctx.spans : void 0
+    });
+  }
+}
+function shouldSample(isError) {
+  if (!store) return false;
+  const rate = isError ? store.errorSampleRate : store.sampleRate;
+  if (rate >= 1) return true;
+  if (rate <= 0) return false;
+  return Math.random() < rate;
+}
+function measureTask(title, fn) {
+  const traceId = (0, import_core4.generateUUID)();
+  const start = Date.now();
+  const startDate = new Date(start);
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      result.then(() => {
+        const durationMs = Date.now() - start;
+        if (shouldSample(false)) {
+          captureTask(traceId, title, durationMs, startDate);
+        }
+      }).catch((err) => {
+        const durationMs = Date.now() - start;
+        if (shouldSample(true)) {
+          captureTask(traceId, title, durationMs, startDate);
+          if (err instanceof Error) {
+            captureExceptionWithAttributes(err, void 0, traceId);
+          }
+        }
+        throw err;
+      });
+    } else {
+      const durationMs = Date.now() - start;
+      if (shouldSample(false)) {
+        captureTask(traceId, title, durationMs, startDate);
+      }
+    }
+  } catch (err) {
+    const durationMs = Date.now() - start;
+    if (shouldSample(true)) {
+      captureTask(traceId, title, durationMs, startDate);
+      if (err instanceof Error) {
+        captureExceptionWithAttributes(err, void 0, traceId);
+      }
+    }
+    throw err;
+  }
+}
+async function shutdown() {
+  if (!store) return;
+  const s = store;
+  store = null;
+  await s.shutdown();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionFrameStore,
+  addSpanToContext,
+  captureCurrentTrace,
+  captureException,
+  captureExceptionWithAttributes,
+  captureMessage,
+  captureMetric,
+  captureTask,
+  captureTrace,
+  collectMetrics,
+  endSpan,
+  forkTraceContext,
+  formatErrorStackTrace,
+  getTraceContext,
+  getTraceDuration,
+  getTraceId,
+  getTraceSpans,
+  hasTraceContext,
+  init,
+  measureTask,
+  resetCpuTracking,
+  runWithTraceContext,
+  setTraceAttribute,
+  setTraceAttributes,
+  setTraceResponseInfo,
+  shouldSample,
+  shutdown,
+  startSpan,
+  traceContextStorage,
+  withTraceContext
+});
+//# sourceMappingURL=index.js.map