@fabbahiense/pulsar-pino-transport 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -31,9 +31,1316 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   createPulsarTransport: () => createPulsarTransport,
-  default: () => index_default
+  default: () => index_default,
+  extractTrace: () => extractTrace,
+  formatTraceparent: () => formatTraceparent,
+  getTraceContext: () => getTraceContext,
+  injectTrace: () => injectTrace,
+  instrumentAxios: () => instrumentAxios,
+  instrumentFetch: () => instrumentFetch,
+  parseTraceparent: () => parseTraceparent,
+  pinoSpanSink: () => pinoSpanSink,
+  pulsarMixin: () => pulsarMixin,
+  runWithTrace: () => runWithTrace,
+  startSpan: () => startSpan,
+  traceHeaders: () => traceHeaders
 });
 module.exports = __toCommonJS(index_exports);
+
+// ../shared/src/serialize.ts
+var MAX_STRING_CHARS = 32768;
+var MAX_ITEMS = 1e3;
+var MAX_DEPTH = 10;
+var MAX_NODES = 2e4;
+var MAX_TOTAL_CHARS = 1e6;
+var MAX_MESSAGE_CHARS = 32768;
+var MAX_CAUSES = 5;
+function truncateString(value, max) {
+  if (value.length <= max) return value;
+  let end = max;
+  const code = value.charCodeAt(end - 1);
+  if (code >= 55296 && code <= 56319) end--;
+  return `${value.slice(0, end)}\u2026 [truncated ${value.length - end} chars]`;
+}
+function utf8Length(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function describeError(err) {
+  try {
+    return err instanceof Error ? err.message : String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+function functionName(fn) {
+  try {
+    return fn.name ? `[Function: ${fn.name}]` : "[Function (anonymous)]";
+  } catch {
+    return "[Function]";
+  }
+}
+function isPlainContainer(value) {
+  return Array.isArray(value) || value instanceof Map || value instanceof Set;
+}
+function toJsonSafe(value, options = {}) {
+  const state = {
+    maxDepth: options.maxDepth ?? MAX_DEPTH,
+    maxItems: options.maxItems ?? MAX_ITEMS,
+    maxStringChars: options.maxStringChars ?? MAX_STRING_CHARS,
+    nodesLeft: options.maxNodes ?? MAX_NODES,
+    charsLeft: options.maxTotalChars ?? MAX_TOTAL_CHARS,
+    ancestors: /* @__PURE__ */ new Set()
+  };
+  return walk(value, 0, state, false);
+}
+function walk(value, depth, state, inArray) {
+  if (state.nodesLeft <= 0) return "[Truncated]";
+  state.nodesLeft--;
+  switch (typeof value) {
+    case "string":
+      return walkString(value, state);
+    case "number":
+    case "boolean":
+      return value;
+    case "bigint":
+      return value.toString();
+    case "symbol":
+      return value.toString();
+    case "undefined":
+      return inArray ? null : void 0;
+    case "function":
+      return inArray ? null : void 0;
+  }
+  if (value === null) return null;
+  const obj = value;
+  if (state.ancestors.has(obj)) return "[Circular]";
+  try {
+    if (obj instanceof Error) return walkError(obj, depth, state);
+    if (ArrayBuffer.isView(obj)) {
+      return `[${obj.constructor?.name ?? "Binary"}: ${obj.byteLength} bytes]`;
+    }
+    if (obj instanceof ArrayBuffer) return `[ArrayBuffer: ${obj.byteLength} bytes]`;
+    if (obj instanceof Date) {
+      return Number.isNaN(obj.getTime()) ? null : obj.toISOString();
+    }
+    if (obj instanceof RegExp) return obj.toString();
+    const toJSON = obj.toJSON;
+    if (typeof toJSON === "function") {
+      const replaced = toJSON.call(obj);
+      if (replaced !== obj) {
+        state.ancestors.add(obj);
+        try {
+          return walk(replaced, depth, state, inArray);
+        } finally {
+          state.ancestors.delete(obj);
+        }
+      }
+    }
+    if (depth >= state.maxDepth) {
+      return isPlainContainer(obj) ? "[Array]" : "[Object]";
+    }
+    state.ancestors.add(obj);
+    try {
+      if (Array.isArray(obj)) return walkList(obj, obj.length, depth, state);
+      if (obj instanceof Set) return walkList(obj, obj.size, depth, state);
+      if (obj instanceof Map) {
+        const pairs = [];
+        let i = 0;
+        for (const [k, v] of obj) {
+          if (i++ >= state.maxItems) {
+            pairs.push(`\u2026 ${obj.size - state.maxItems} more items`);
+            break;
+          }
+          pairs.push([walk(k, depth + 2, state, true), walk(v, depth + 2, state, true)]);
+        }
+        return pairs;
+      }
+      return walkObject(obj, depth, state);
+    } finally {
+      state.ancestors.delete(obj);
+    }
+  } catch (err) {
+    return `[Unserializable: ${describeError(err)}]`;
+  }
+}
+function walkString(value, state) {
+  if (state.charsLeft <= 0) return "[Truncated]";
+  const kept = truncateString(value, Math.min(state.maxStringChars, state.charsLeft));
+  state.charsLeft -= kept.length;
+  return kept;
+}
+function walkList(list, size, depth, state) {
+  const out = [];
+  let i = 0;
+  for (const item of list) {
+    if (i++ >= state.maxItems) {
+      out.push(`\u2026 ${size - state.maxItems} more items`);
+      break;
+    }
+    out.push(walk(item, depth + 1, state, true));
+  }
+  return out;
+}
+function emptyObject() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function walkObject(obj, depth, state) {
+  const out = emptyObject();
+  const keys = Object.keys(obj);
+  let limit = Math.min(keys.length, state.maxItems);
+  for (let i = 0; i < limit; i++) {
+    const key = keys[i];
+    if (state.charsLeft <= 0) {
+      limit = i;
+      break;
+    }
+    state.charsLeft -= key.length;
+    let child;
+    try {
+      child = obj[key];
+    } catch (err) {
+      out[key] = `[Unserializable: ${describeError(err)}]`;
+      continue;
+    }
+    const safe = walk(child, depth + 1, state, false);
+    if (safe !== void 0) out[key] = safe;
+  }
+  if (keys.length > limit) out["\u2026"] = `${keys.length - limit} more keys`;
+  return out;
+}
+function walkError(err, depth, state) {
+  const out = emptyObject();
+  state.ancestors.add(err);
+  try {
+    out.name = walk(readProp(err, "name"), depth + 1, state, false);
+    out.message = walk(readProp(err, "message"), depth + 1, state, false);
+    const stack = readProp(err, "stack");
+    if (stack !== void 0) out.stack = walk(stack, depth + 1, state, false);
+    for (const key of Object.keys(err)) {
+      if (key in out || key === "cause") continue;
+      const safe = walk(readProp(err, key), depth + 1, state, false);
+      if (safe !== void 0) out[key] = safe;
+    }
+    const cause = readProp(err, "cause");
+    if (cause !== void 0) {
+      out.cause = depth + 1 >= state.maxDepth ? "[Object]" : walk(cause, depth + 1, state, false);
+    }
+    return out;
+  } finally {
+    state.ancestors.delete(err);
+  }
+}
+function readProp(obj, key) {
+  try {
+    return obj[key];
+  } catch (err) {
+    return `[Unserializable: ${describeError(err)}]`;
+  }
+}
+function safeStringify(value, options) {
+  const json = JSON.stringify(toJsonSafe(value, options));
+  return json === void 0 ? String(json) : json;
+}
+function errorSummary(err) {
+  try {
+    const text2 = String(err);
+    if (text2 && text2 !== "[object Object]") return text2;
+  } catch {
+  }
+  const name = readProp(err, "name");
+  const message = readProp(err, "message");
+  return `${typeof name === "string" ? name : "Error"}: ${typeof message === "string" ? message : ""}`;
+}
+function errorDetails(err) {
+  const rawMessage = readProp(err, "message");
+  const message = truncateString(typeof rawMessage === "string" ? rawMessage : safeStringify(rawMessage), MAX_STRING_CHARS);
+  const parts = [stackOf(err)];
+  const seen = /* @__PURE__ */ new Set([err]);
+  let cause = readProp(err, "cause");
+  for (let i = 0; i < MAX_CAUSES && cause !== void 0 && cause !== null && !seen.has(cause); i++) {
+    seen.add(cause);
+    parts.push(`Caused by: ${cause instanceof Error ? stackOf(cause) : safeStringify(cause)}`);
+    cause = cause instanceof Error ? readProp(cause, "cause") : void 0;
+  }
+  return { message, stack: truncateString(parts.join("\n"), MAX_STRING_CHARS * 2) };
+}
+function stackOf(err) {
+  const stack = readProp(err, "stack");
+  return typeof stack === "string" && stack.length > 0 ? stack : errorSummary(err);
+}
+function formatArgs(args) {
+  const parts = [];
+  let length = 0;
+  for (const arg of args) {
+    const part = formatArg(arg);
+    parts.push(part);
+    length += part.length + 1;
+    if (length > MAX_MESSAGE_CHARS) break;
+  }
+  return truncateString(parts.join(" "), MAX_MESSAGE_CHARS);
+}
+function formatArg(arg) {
+  switch (typeof arg) {
+    case "string":
+      return truncateString(arg, MAX_MESSAGE_CHARS);
+    case "bigint":
+      return `${arg}n`;
+    case "symbol":
+      return arg.toString();
+    case "function":
+      return functionName(arg);
+    case "undefined":
+      return "undefined";
+  }
+  if (arg instanceof Error) return errorSummary(arg);
+  return safeStringify(arg, { maxStringChars: MAX_MESSAGE_CHARS });
+}
+
+// ../shared/src/delivery.ts
+var SERVER_MAX_BATCH = 1e3;
+var DEFAULT_BATCH_SIZE = 50;
+var DEFAULT_FLUSH_INTERVAL = 2e3;
+var DEFAULT_MAX_BUFFER_SIZE = 5e3;
+var DEFAULT_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var DEFAULT_MAX_RETRIES = 10;
+var DEFAULT_REQUEST_TIMEOUT = 1e4;
+var DEFAULT_SHUTDOWN_TIMEOUT = 3e3;
+var DEFAULT_MAX_ENTRY_BYTES = 256 * 1024;
+var DEFAULT_MAX_BATCH_BYTES = 512 * 1024;
+var RETRY_BASE_MS = 1e3;
+var RETRY_MAX_MS = 3e4;
+var RETRY_AFTER_MAX_MS = 10 * 6e4;
+var MIN_BATCH_BYTES = 1024;
+var INTERNAL_REQUEST = /* @__PURE__ */ Symbol.for("@fabbahiense/pulsar.internal-request");
+function unref(timer) {
+  const t = timer;
+  if (typeof t === "object" && t !== null && typeof t.unref === "function") t.unref();
+  return timer;
+}
+function ref(timer) {
+  const t = timer;
+  if (typeof t === "object" && t !== null && typeof t.ref === "function") t.ref();
+}
+function positive(value, fallback, min = 1) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min ? value : fallback;
+}
+function nonNegative(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+function generateId() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}${Math.random().toString(36).slice(2, 12)}`;
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (value === null || value === void 0) return null;
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  let ms;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    ms = Number(trimmed) * 1e3;
+  } else {
+    const date = Date.parse(trimmed);
+    if (Number.isNaN(date)) return null;
+    ms = date - now;
+  }
+  return Math.min(Math.max(ms, 0), RETRY_AFTER_MAX_MS);
+}
+function serializeEntry(entry, maxBytes) {
+  const safe = toJsonSafe(entry, { maxTotalChars: maxBytes });
+  let json = JSON.stringify(safe);
+  let bytes = utf8Length(json);
+  if (bytes <= maxBytes) return { json, bytes };
+  if (safe.metadata !== void 0 && safe.metadata !== null) {
+    const metaJson = JSON.stringify(safe.metadata);
+    safe.metadata = {
+      _truncated: `metadata was ${utf8Length(metaJson)} bytes; entries are capped at ${maxBytes} bytes`,
+      _preview: truncateString(metaJson, 2048)
+    };
+    json = JSON.stringify(safe);
+    bytes = utf8Length(json);
+    if (bytes <= maxBytes) return { json, bytes };
+  }
+  for (const share of [8, 32]) {
+    const limit = Math.max(256, Math.floor(maxBytes / share));
+    for (const field of ["msg", "errorStack", "errorMessage", "url", "traceId"]) {
+      const value = safe[field];
+      if (typeof value === "string") safe[field] = truncateString(value, limit);
+    }
+    json = JSON.stringify(safe);
+    bytes = utf8Length(json);
+    if (bytes <= maxBytes) return { json, bytes };
+  }
+  const minimal = {};
+  for (const [key, value] of Object.entries(safe)) {
+    if (typeof value === "string") minimal[key] = truncateString(value, 256);
+    else if (typeof value !== "object" || value === null) minimal[key] = value;
+  }
+  minimal.metadata = { _truncated: `entry exceeded ${maxBytes} bytes` };
+  json = JSON.stringify(minimal);
+  return { json, bytes: utf8Length(json) };
+}
+function createDropWarner(name, intervalMs = 6e4) {
+  let lastAt = 0;
+  const pending = { overflow: 0, rejected: 0, retriesExhausted: 0, shutdown: 0 };
+  let detail = "";
+  return (event) => {
+    pending[event.reason] += event.count;
+    if (event.error || event.status) detail = `${event.status ?? ""}${event.status && event.error ? " " : ""}${event.error ?? ""}`;
+    const now = Date.now();
+    if (now - lastAt < intervalMs && event.reason !== "shutdown") return;
+    lastAt = now;
+    const parts = Object.keys(pending).filter((r) => pending[r] > 0).map((r) => `${pending[r]} ${r}`);
+    const line = `[${name}] dropped logs: ${parts.join(", ")}${detail ? ` (last error: ${detail})` : ""}
+`;
+    for (const r of Object.keys(pending)) pending[r] = 0;
+    detail = "";
+    writeStderr(line);
+  };
+}
+function writeStderr(line, target = globalThis.process) {
+  try {
+    const proc = target;
+    if (proc?.stderr && typeof proc.stderr.write === "function") {
+      proc.stderr.write(line);
+      return;
+    }
+    if (typeof console !== "undefined") console.warn(line.trimEnd());
+  } catch {
+  }
+}
+var Queue = class {
+  items = [];
+  head = 0;
+  bytes = 0;
+  get length() {
+    return this.items.length - this.head;
+  }
+  push(rec) {
+    this.items.push(rec);
+    this.bytes += rec.bytes;
+  }
+  shift() {
+    if (this.head >= this.items.length) return void 0;
+    const rec = this.items[this.head];
+    this.items[this.head] = void 0;
+    this.head++;
+    this.bytes -= rec.bytes;
+    if (this.head > 1024 && this.head * 2 > this.items.length) {
+      this.items = this.items.slice(this.head);
+      this.head = 0;
+    }
+    return rec;
+  }
+  peek() {
+    return this.head < this.items.length ? this.items[this.head] : void 0;
+  }
+  /** Puts entries back at the front, keeping their order. */
+  unshiftAll(recs) {
+    if (recs.length === 0) return;
+    this.items = recs.concat(this.items.slice(this.head));
+    this.head = 0;
+    for (const rec of recs) this.bytes += rec.bytes;
+  }
+  clear() {
+    const n = this.length;
+    this.items = [];
+    this.head = 0;
+    this.bytes = 0;
+    return n;
+  }
+};
+var EXIT_GRACE_MS = 1e3;
+var Delivery = class {
+  queue = new Queue();
+  endpoint;
+  apiKey;
+  batchSize;
+  flushInterval;
+  maxBufferSize;
+  maxBufferBytes;
+  maxRetries;
+  requestTimeout;
+  shutdownTimeout;
+  maxEntryBytes;
+  maxBatchBytes;
+  /** Entries per request; lowered by a 413 split, then grows back. */
+  maxBatchEntries;
+  single;
+  keepalive;
+  onDrop;
+  fetchImpl;
+  random;
+  /** Pending flush-interval or backoff timer (never both). */
+  timer = null;
+  /** True while waiting out a backoff; sends are held until the timer fires. */
+  backingOff = false;
+  backoffUntil = 0;
+  backoffWaiters = [];
+  inflight = null;
+  inflightCount = 0;
+  /** Consecutive retryable failures of the batch at the head of the queue. */
+  attempt = 0;
+  /** Size of the batch at the head of the queue that awaits a retry (0 = none). */
+  retryCount = 0;
+  /** >0 while a flush()/close() wants everything sent now, not just full batches. */
+  draining = 0;
+  /** Deadline of the innermost running flush (0 = none). */
+  drainDeadline = 0;
+  /** Deadline of the current beforeExit episode (0 = none). */
+  exitDeadline = 0;
+  closed = false;
+  counters = {
+    sent: 0,
+    buffered: 0,
+    retries: 0,
+    dropped: { overflow: 0, rejected: 0, retriesExhausted: 0, shutdown: 0 }
+  };
+  constructor(options) {
+    const base = String(options.url ?? "").replace(/\/+$/, "");
+    this.single = options.single === true;
+    this.endpoint = `${base}${this.single ? "/api/ingest" : "/api/ingest/batch"}`;
+    this.apiKey = options.apiKey ?? "";
+    this.batchSize = this.single ? 1 : Math.min(Math.floor(positive(options.batchSize, DEFAULT_BATCH_SIZE)), SERVER_MAX_BATCH);
+    this.flushInterval = positive(options.flushInterval, DEFAULT_FLUSH_INTERVAL);
+    this.maxBufferSize = Math.floor(positive(options.maxBufferSize, DEFAULT_MAX_BUFFER_SIZE));
+    this.maxBufferBytes = positive(options.maxBufferBytes, DEFAULT_MAX_BUFFER_BYTES);
+    this.maxRetries = nonNegative(options.maxRetries, DEFAULT_MAX_RETRIES);
+    this.requestTimeout = positive(options.requestTimeout, DEFAULT_REQUEST_TIMEOUT);
+    this.shutdownTimeout = nonNegative(options.shutdownTimeout, DEFAULT_SHUTDOWN_TIMEOUT);
+    this.maxEntryBytes = positive(options.maxEntryBytes, DEFAULT_MAX_ENTRY_BYTES, 512);
+    this.maxBatchBytes = Math.max(positive(options.maxBatchBytes, DEFAULT_MAX_BATCH_BYTES, MIN_BATCH_BYTES), MIN_BATCH_BYTES);
+    this.maxBatchEntries = this.single ? 1 : SERVER_MAX_BATCH;
+    this.keepalive = options.keepalive === true;
+    this.onDrop = options.onDrop ?? createDropWarner(options.name ?? "pulsar");
+    this.fetchImpl = options.fetch;
+    this.random = options.random ?? (() => Math.random());
+  }
+  /** Queues one entry. Synchronous; never throws. */
+  push(entry) {
+    try {
+      if (this.closed) {
+        this.drop("shutdown", 1);
+        return;
+      }
+      if (!entry.id) entry.id = generateId();
+      this.queue.push(serializeEntry(entry, this.maxEntryBytes));
+      this.enforceLimits();
+      const now = Date.now();
+      if (this.exitDeadline !== 0 && now < this.exitDeadline) {
+        this.kick();
+      } else if (this.exitDeadline !== 0 && now <= this.exitDeadline + EXIT_GRACE_MS) {
+        this.armFlushTimer();
+      } else if (this.queue.length >= this.batchSize) {
+        this.kick();
+      } else {
+        this.armFlushTimer();
+      }
+    } catch {
+    }
+  }
+  /** Snapshot of the delivery counters. */
+  stats() {
+    return {
+      ...this.counters,
+      buffered: this.queue.length + this.inflightCount,
+      dropped: { ...this.counters.dropped }
+    };
+  }
+  /**
+   * Sends everything buffered now, retrying retryable failures (and honouring
+   * backoff) until the buffer is empty or `timeout` ms pass; it resolves by
+   * then at the latest. Entries still undelivered stay buffered for the
+   * background retry. Never rejects.
+   */
+  async flush(timeout = this.shutdownTimeout) {
+    const deadline = Date.now() + Math.max(0, timeout);
+    this.draining++;
+    const previousDeadline = this.drainDeadline;
+    this.drainDeadline = previousDeadline === 0 ? deadline : Math.min(previousDeadline, deadline);
+    try {
+      for (; ; ) {
+        const left = deadline - Date.now();
+        if (this.inflight) {
+          if (left <= 0) return;
+          await settleWithin(this.inflight, left);
+          continue;
+        }
+        if (this.queue.length === 0 || left <= 0) return;
+        if (this.backingOff) {
+          if (this.backoffUntil > deadline) return;
+          ref(this.timer);
+          await new Promise((resolve) => this.backoffWaiters.push(resolve));
+          continue;
+        }
+        this.kick();
+        if (!this.inflight) return;
+      }
+    } catch {
+    } finally {
+      this.draining--;
+      this.drainDeadline = this.draining === 0 ? 0 : previousDeadline;
+    }
+  }
+  /**
+   * Flushes (bounded by `shutdownTimeout`), stops timers and drops whatever
+   * is still undelivered, counted as `shutdown`. Entries pushed afterwards
+   * are dropped too. Never rejects.
+   */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    await this.flush(this.shutdownTimeout);
+    this.dropBuffered("shutdown");
+  }
+  /**
+   * Hook for `process.on('beforeExit')`. Sends what is left, keeping the
+   * process alive only while a request (or a retry due before the deadline)
+   * is pending, for at most `shutdownTimeout` per exit. What can't be sent in
+   * time is dropped and counted (`shutdown`) so the process can exit.
+   */
+  onBeforeExit() {
+    if (this.closed) return;
+    const now = Date.now();
+    if (this.exitDeadline === 0 || now > this.exitDeadline + EXIT_GRACE_MS) {
+      this.exitDeadline = now + this.shutdownTimeout;
+    }
+    if (this.queue.length === 0 && !this.inflight) return;
+    const remaining = this.exitDeadline - now;
+    if (remaining <= 0 || this.backingOff && this.backoffUntil > this.exitDeadline) {
+      this.dropBuffered("shutdown");
+      return;
+    }
+    void this.flush(remaining);
+  }
+  /** Hook for termination signals: flush within `shutdownTimeout`, then drop the rest. */
+  async onSignal() {
+    if (this.closed) return;
+    await this.flush(this.shutdownTimeout);
+    this.dropBuffered("shutdown");
+  }
+  dropBuffered(reason) {
+    this.clearTimer();
+    this.backingOff = false;
+    this.backoffUntil = 0;
+    this.wakeBackoffWaiters();
+    const n = this.queue.clear();
+    if (n > 0) this.drop(reason, n);
+  }
+  drop(reason, count, status, error) {
+    if (count <= 0) return;
+    this.counters.dropped[reason] += count;
+    try {
+      this.onDrop({ reason, count, ...status !== void 0 ? { status } : {}, ...error ? { error } : {} });
+    } catch {
+    }
+  }
+  enforceLimits() {
+    let evicted = 0;
+    while (this.queue.length > this.maxBufferSize || this.queue.bytes > this.maxBufferBytes && this.queue.length > 1) {
+      this.queue.shift();
+      evicted++;
+    }
+    if (evicted > 0) {
+      if (this.retryCount > 0) {
+        this.retryCount = Math.max(0, this.retryCount - evicted);
+        if (this.retryCount === 0) this.attempt = 0;
+      }
+      this.drop("overflow", evicted);
+    }
+  }
+  clearTimer() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Arms the flush-interval timer; `fromLoop` is the send loop handing over. */
+  armFlushTimer(fromLoop = false) {
+    if (this.timer !== null || this.inflight && !fromLoop || this.backingOff || this.closed || this.queue.length === 0) return;
+    this.timer = unref(setTimeout(() => {
+      this.timer = null;
+      this.kick();
+    }, this.flushInterval));
+  }
+  wakeBackoffWaiters() {
+    const waiters = this.backoffWaiters;
+    this.backoffWaiters = [];
+    for (const wake of waiters) wake();
+  }
+  /** Starts the send loop unless a request is in flight or a backoff is pending. */
+  kick() {
+    if (this.inflight || this.backingOff || this.queue.length === 0) return;
+    this.clearTimer();
+    const run = this.sendLoop().catch(() => void 0).finally(() => {
+      if (this.inflight === run) this.inflight = null;
+    });
+    this.inflight = run;
+  }
+  /** Whether to send the next batch now rather than wait for it to fill. */
+  eager() {
+    const now = Date.now();
+    if (this.queue.length >= this.batchSize) return true;
+    if (this.draining > 0 && (this.drainDeadline === 0 || now < this.drainDeadline)) return true;
+    return this.exitDeadline !== 0 && now < this.exitDeadline;
+  }
+  async sendLoop() {
+    while (this.queue.length > 0) {
+      const batch = this.takeBatch();
+      this.retryCount = 0;
+      this.inflightCount = batch.length;
+      let outcome;
+      try {
+        outcome = await this.send(batch);
+      } catch (err) {
+        outcome = { kind: "retry", retryAfter: null, error: err instanceof Error ? err.message : "send failed" };
+      }
+      this.inflightCount = 0;
+      if (this.closed && this.draining === 0 && (outcome.kind === "retry" || outcome.kind === "tooLarge")) {
+        this.drop("shutdown", batch.length, outcome.status);
+        return;
+      }
+      switch (outcome.kind) {
+        case "ok":
+          this.attempt = 0;
+          this.counters.sent += batch.length - outcome.rejected;
+          if (outcome.rejected > 0) this.drop("rejected", outcome.rejected, void 0, "entry rejected by server");
+          this.maxBatchEntries = Math.min(SERVER_MAX_BATCH, this.maxBatchEntries * 2);
+          break;
+        case "reject":
+          this.attempt = 0;
+          this.drop("rejected", batch.length, outcome.status, outcome.error);
+          break;
+        case "tooLarge":
+          if (batch.length > 1) {
+            const bytes = batch.reduce((sum, r) => sum + r.bytes, 0);
+            this.maxBatchBytes = Math.max(MIN_BATCH_BYTES, Math.floor(bytes / 2));
+            this.maxBatchEntries = Math.max(1, Math.floor(batch.length / 2));
+            this.queue.unshiftAll(batch);
+            this.enforceLimits();
+            continue;
+          }
+          this.attempt = 0;
+          this.drop("rejected", 1, 413, "entry too large for the server");
+          break;
+        case "retry":
+          this.counters.retries++;
+          this.attempt++;
+          if (this.attempt > this.maxRetries) {
+            this.attempt = 0;
+            this.drop("retriesExhausted", batch.length, outcome.status, outcome.error);
+            if (this.queue.length > 0) this.startBackoff(this.backoffDelay(1, outcome.retryAfter));
+            return;
+          }
+          this.queue.unshiftAll(batch);
+          this.retryCount = batch.length;
+          this.enforceLimits();
+          this.startBackoff(this.backoffDelay(this.attempt, outcome.retryAfter));
+          return;
+      }
+      if (this.queue.length === 0) return;
+      if (!this.eager()) {
+        this.armFlushTimer(true);
+        return;
+      }
+    }
+  }
+  backoffDelay(attempt, retryAfter) {
+    if (retryAfter !== null) {
+      return retryAfter + Math.floor(this.random() * Math.min(1e3, retryAfter * 0.1 + 100));
+    }
+    const exp = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** (attempt - 1));
+    return Math.floor(exp / 2 + this.random() * (exp / 2));
+  }
+  startBackoff(delay) {
+    this.clearTimer();
+    this.backingOff = true;
+    this.backoffUntil = Date.now() + delay;
+    this.timer = unref(setTimeout(() => {
+      this.timer = null;
+      this.backingOff = false;
+      this.backoffUntil = 0;
+      this.wakeBackoffWaiters();
+      this.kick();
+    }, delay));
+  }
+  takeBatch() {
+    const batch = [];
+    let bytes = 12;
+    const retrying = this.retryCount > 0;
+    const maxCount = this.single ? 1 : retrying ? this.retryCount : this.maxBatchEntries;
+    for (; ; ) {
+      const next = this.queue.peek();
+      if (!next || batch.length >= maxCount) break;
+      if (!retrying && batch.length > 0 && bytes + next.bytes + 1 > this.maxBatchBytes) break;
+      this.queue.shift();
+      batch.push(next);
+      bytes += next.bytes + 1;
+    }
+    return batch;
+  }
+  requestTimeoutNow() {
+    const now = Date.now();
+    let timeout = this.requestTimeout;
+    for (const deadline of [this.drainDeadline, this.exitDeadline]) {
+      if (deadline !== 0 && deadline > now) timeout = Math.min(timeout, deadline - now);
+    }
+    return Math.max(1, timeout);
+  }
+  async send(batch) {
+    const fetchImpl = this.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      return { kind: "reject", error: "fetch is not available in this runtime" };
+    }
+    const body = this.single ? batch[0].json : `{"logs":[${batch.map((r) => r.json).join(",")}]}`;
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    const timeout = this.requestTimeoutNow();
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    const timer = controller ? unref(setTimeout(() => controller.abort(), timeout)) : null;
+    const init = {
+      method: "POST",
+      headers,
+      body,
+      ...controller ? { signal: controller.signal } : {},
+      ...this.keepalive ? { keepalive: true } : {}
+    };
+    init[INTERNAL_REQUEST] = true;
+    try {
+      const res = await fetchImpl(this.endpoint, init);
+      const text2 = await readText(res);
+      return classify(res, text2, batch.length);
+    } catch (err) {
+      const aborted = controller?.signal.aborted === true;
+      return {
+        kind: "retry",
+        retryAfter: null,
+        error: aborted ? `request timed out after ${timeout} ms` : err instanceof Error ? err.message : "network error"
+      };
+    } finally {
+      if (timer !== null) clearTimeout(timer);
+    }
+  }
+};
+function settleWithin(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = unref(setTimeout(resolve, ms));
+    promise.then(
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    );
+  });
+}
+async function readText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+function errorText(res, text2) {
+  try {
+    const parsed = JSON.parse(text2);
+    if (typeof parsed?.error === "string") return truncateString(parsed.error, 200);
+  } catch {
+  }
+  return res.statusText || `HTTP ${res.status}`;
+}
+function classify(res, text2, count) {
+  const status = res.status;
+  if (status >= 200 && status < 300) {
+    const contentType = res.headers.get("content-type") ?? "";
+    if (res.redirected && !contentType.includes("json")) {
+      return { kind: "reject", status, error: `redirected to ${res.url}; set url to the final address` };
+    }
+    let rejected = 0;
+    if (contentType.includes("json") && text2.length > 0 && text2.length < 1e6) {
+      try {
+        const parsed = JSON.parse(text2);
+        if (Array.isArray(parsed?.failed)) rejected = Math.min(parsed.failed.length, count);
+      } catch {
+      }
+    }
+    return { kind: "ok", rejected };
+  }
+  if (status === 413) return { kind: "tooLarge" };
+  if (status === 429 || status === 408 || status >= 500) {
+    return { kind: "retry", retryAfter: parseRetryAfter(res.headers.get("retry-after")), status, error: errorText(res, text2) };
+  }
+  return { kind: "reject", status, error: errorText(res, text2) };
+}
+
+// ../shared/src/trace.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var TRACE_ID_HEADER = "x-trace-id";
+var MAX_TRACESTATE_CHARS = 512;
+var ZERO_TRACE_ID = "0".repeat(32);
+var ZERO_SPAN_ID = "0".repeat(16);
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(-.*)?$/;
+var TRACE_ID_RE = /^[0-9a-f]{32}$/;
+var SPAN_ID_RE = /^[0-9a-f]{16}$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function newTraceId() {
+  for (; ; ) {
+    const id = (0, import_node_crypto.randomBytes)(16).toString("hex");
+    if (id !== ZERO_TRACE_ID) return id;
+  }
+}
+function newSpanId() {
+  for (; ; ) {
+    const id = (0, import_node_crypto.randomBytes)(8).toString("hex");
+    if (id !== ZERO_SPAN_ID) return id;
+  }
+}
+function sha256Hex(value) {
+  return (0, import_node_crypto.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function toW3CTraceId(traceId) {
+  const lower = traceId.toLowerCase();
+  if (TRACE_ID_RE.test(lower) && lower !== ZERO_TRACE_ID) return lower;
+  if (UUID_RE.test(lower)) {
+    const hex = lower.replace(/-/g, "");
+    if (hex !== ZERO_TRACE_ID) return hex;
+  }
+  return sha256Hex(traceId).slice(0, 32);
+}
+function toW3CSpanId(spanId) {
+  const lower = spanId.toLowerCase();
+  if (SPAN_ID_RE.test(lower) && lower !== ZERO_SPAN_ID) return lower;
+  return sha256Hex(spanId).slice(0, 16);
+}
+function parseTraceparent(value) {
+  if (typeof value !== "string") return null;
+  const header = value.trim();
+  const match = TRACEPARENT_RE.exec(header);
+  if (!match) return null;
+  const [, version, traceId, parentId, flagsHex, rest] = match;
+  if (version === "ff") return null;
+  if (version === "00" && rest !== void 0) return null;
+  if (traceId === ZERO_TRACE_ID || parentId === ZERO_SPAN_ID) return null;
+  const flags = parseInt(flagsHex, 16);
+  return { version, traceId, parentId, flags, sampled: (flags & 1) === 1 };
+}
+function formatTraceparent(ctx) {
+  return `00-${toW3CTraceId(ctx.traceId)}-${toW3CSpanId(ctx.spanId)}-${ctx.sampled === false ? "00" : "01"}`;
+}
+var STORE_KEY = /* @__PURE__ */ Symbol.for("@fabbahiense/pulsar.trace-context.v1");
+function sharedStore() {
+  const g = globalThis;
+  let store = g[STORE_KEY];
+  if (!store) {
+    store = new import_node_async_hooks.AsyncLocalStorage();
+    g[STORE_KEY] = store;
+  }
+  return store;
+}
+var traceStore = sharedStore();
+function getTraceContext() {
+  return traceStore.getStore() ?? null;
+}
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function completeContext(init) {
+  const ctx = {
+    traceId: text(init?.traceId) ?? newTraceId(),
+    spanId: text(init?.spanId) ?? newSpanId(),
+    sampled: init?.sampled !== false
+  };
+  const parentSpanId = text(init?.parentSpanId);
+  if (parentSpanId) ctx.parentSpanId = parentSpanId;
+  const traceState = text(init?.traceState);
+  if (traceState) ctx.traceState = traceState;
+  const method = text(init?.method);
+  if (method) ctx.method = method;
+  const url = text(init?.url);
+  if (url) ctx.url = url;
+  return ctx;
+}
+function childContext(parent) {
+  if (!parent || !text(parent.traceId)) return completeContext(null);
+  const local = parent;
+  return completeContext({
+    traceId: parent.traceId,
+    parentSpanId: parent.spanId,
+    sampled: parent.sampled,
+    traceState: parent.traceState,
+    method: local.method,
+    url: local.url
+  });
+}
+function runWithTrace(ctx, fn) {
+  return traceStore.run(completeContext(ctx), fn);
+}
+function read(carrier, name) {
+  let value;
+  if (typeof carrier.get === "function") {
+    value = carrier.get(name);
+  } else {
+    const record = carrier;
+    value = record[name];
+    if (value === void 0) {
+      for (const key of Object.keys(record)) {
+        if (key.toLowerCase() === name) {
+          value = record[key];
+          break;
+        }
+      }
+    }
+  }
+  if (Array.isArray(value)) value = value.find((v) => typeof v === "string");
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readTraceState(carrier) {
+  let raw;
+  if (typeof carrier.get === "function") {
+    raw = carrier.get(TRACESTATE_HEADER);
+  } else {
+    const record = carrier;
+    raw = record[TRACESTATE_HEADER];
+    if (raw === void 0) {
+      const key = Object.keys(record).find((k) => k.toLowerCase() === TRACESTATE_HEADER);
+      raw = key === void 0 ? void 0 : record[key];
+    }
+  }
+  const joined = Array.isArray(raw) ? raw.filter((v) => typeof v === "string").join(",") : raw;
+  if (typeof joined !== "string") return void 0;
+  const value = joined.trim();
+  return value.length > 0 && value.length <= MAX_TRACESTATE_CHARS ? value : void 0;
+}
+function extractTrace(carrier) {
+  if (typeof carrier !== "object" || carrier === null) return null;
+  try {
+    const source = carrier;
+    const legacy = read(source, TRACE_ID_HEADER);
+    const parent = parseTraceparent(read(source, TRACEPARENT_HEADER));
+    if (legacy !== void 0) {
+      if (parent && parent.traceId === toW3CTraceId(legacy)) {
+        return withTraceState({ traceId: legacy, spanId: parent.parentId, sampled: parent.sampled }, source);
+      }
+      return { traceId: legacy, sampled: true };
+    }
+    if (parent) return withTraceState({ traceId: parent.traceId, spanId: parent.parentId, sampled: parent.sampled }, source);
+    return null;
+  } catch {
+    return null;
+  }
+}
+function withTraceState(trace, carrier) {
+  const traceState = readTraceState(carrier);
+  if (traceState) trace.traceState = traceState;
+  return trace;
+}
+function traceHeaders(ctx = getTraceContext()) {
+  if (!ctx) return {};
+  const headers = {
+    [TRACEPARENT_HEADER]: formatTraceparent(ctx),
+    [TRACE_ID_HEADER]: ctx.traceId
+  };
+  if (ctx.traceState) headers[TRACESTATE_HEADER] = ctx.traceState;
+  return headers;
+}
+function injectTrace(carrier, ctx = getTraceContext()) {
+  if (!ctx || typeof carrier !== "object" || carrier === null) return carrier;
+  try {
+    const headers = traceHeaders(ctx);
+    const target = carrier;
+    for (const [name, value] of Object.entries(headers)) {
+      if (typeof target.set === "function") target.set(name, value);
+      else carrier[name] = value;
+    }
+  } catch {
+  }
+  return carrier;
+}
+function round3(ms) {
+  return Math.round(ms * 1e3) / 1e3;
+}
+function isThenable(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function openSpan(ctx, kind, sink, base = {}) {
+  const start = Date.now();
+  const t0 = performance.now();
+  let done = false;
+  return (name, extra = {}) => {
+    if (done || !sink) return;
+    done = true;
+    try {
+      const duration = round3(performance.now() - t0);
+      sink({ ...base, ...extra, name, kind, context: ctx, start, end: start + duration, duration });
+    } catch {
+    }
+  };
+}
+function runSpan(name, fn, options = {}, sink = null) {
+  const parent = options.parent === void 0 ? getTraceContext() : options.parent;
+  const ctx = childContext(parent);
+  const spanName = typeof name === "string" ? name || "span" : name === void 0 || name === null ? "span" : formatArgs([name]);
+  const finish = openSpan(ctx, options.kind ?? "internal", sink, {
+    attributes: options.attributes,
+    serviceName: options.serviceName
+  });
+  let result;
+  try {
+    result = traceStore.run(ctx, () => fn(ctx));
+  } catch (err) {
+    finish(spanName, { error: err });
+    throw err;
+  }
+  if (isThenable(result)) {
+    return result.then(
+      (value) => {
+        finish(spanName);
+        return value;
+      },
+      (err) => {
+        finish(spanName, { error: err });
+        throw err;
+      }
+    );
+  }
+  finish(spanName);
+  return result;
+}
+function asError(value) {
+  return value instanceof Error ? value : new Error(formatArgs([value]));
+}
+function spanLevel(span) {
+  if (span.error !== void 0) return "error";
+  const status = span.statusCode;
+  if (typeof status === "number" && status >= 500) return "error";
+  if (typeof status === "number" && status >= 400) return "warn";
+  return "info";
+}
+function spanEntry(span) {
+  const details = span.error !== void 0 ? errorDetails(asError(span.error)) : void 0;
+  const entry = {
+    level: spanLevel(span),
+    msg: span.name,
+    timestamp: Math.round(span.end),
+    traceId: span.context.traceId,
+    spanId: span.context.spanId,
+    spanKind: span.kind,
+    responseTime: span.duration,
+    metadata: span.attributes ? toJsonSafe(span.attributes) : null
+  };
+  if (span.context.parentSpanId) entry.parentSpanId = span.context.parentSpanId;
+  if (span.method) entry.method = span.method;
+  if (span.url) entry.url = span.url;
+  if (span.statusCode !== void 0) entry.statusCode = span.statusCode;
+  if (details) {
+    entry.errorMessage = details.message;
+    entry.errorStack = details.stack;
+  }
+  return entry;
+}
+var INTERNAL_REQUEST2 = /* @__PURE__ */ Symbol.for("@fabbahiense/pulsar.internal-request");
+var INSTRUMENTED = /* @__PURE__ */ Symbol.for("@fabbahiense/pulsar.instrumented");
+function safeUrl(raw) {
+  try {
+    const url = new URL(raw);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return raw.split(/[?#]/)[0];
+  }
+}
+function clientSpanName(method, url, status) {
+  return `${method} ${url} ${status === void 0 ? "failed" : status}`;
+}
+function startOutbound(options, getSink, method, url) {
+  const parent = getTraceContext();
+  if (!parent) return null;
+  const sink = options.spans === false ? null : getSink();
+  const span = sink ? childContext(parent) : parent;
+  const finish = openSpan(span, "client", sink, { method, url, serviceName: options.serviceName });
+  return {
+    headers: traceHeaders(span),
+    end(status, error) {
+      finish(clientSpanName(method, url, status), status === void 0 ? { error } : { statusCode: status });
+    }
+  };
+}
+function requestParts(input, init) {
+  const isRequest = typeof Request === "function" && input instanceof Request;
+  const method = String(init?.method ?? (isRequest ? input.method : "GET")).toUpperCase();
+  const url = isRequest ? input.url : String(input);
+  const base = init?.headers ?? (isRequest ? input.headers : void 0);
+  return { method, url, base };
+}
+function wrapFetch(fetchImpl, options, getSink) {
+  if (typeof fetchImpl !== "function") throw new TypeError("instrumentFetch: no fetch implementation to wrap");
+  if (fetchImpl[INSTRUMENTED]) return fetchImpl;
+  const wrapped = function(input, init) {
+    let call = null;
+    let nextInit = init;
+    try {
+      if (!init?.[INTERNAL_REQUEST2]) {
+        const { method, url, base } = requestParts(input, init);
+        call = startOutbound(options, getSink, method, safeUrl(url));
+        if (call) {
+          const headers = new Headers(base);
+          for (const [name, value] of Object.entries(call.headers)) headers.set(name, value);
+          nextInit = { ...init, headers };
+        }
+      }
+    } catch {
+      call = null;
+      nextInit = init;
+    }
+    const pending = fetchImpl(input, nextInit);
+    if (!call) return pending;
+    const active = call;
+    return pending.then(
+      (res) => {
+        active.end(res.status);
+        return res;
+      },
+      (err) => {
+        active.end(void 0, err);
+        throw err;
+      }
+    );
+  };
+  Object.defineProperty(wrapped, INSTRUMENTED, { value: true });
+  return wrapped;
+}
+function axiosUrl(config) {
+  const url = typeof config.url === "string" ? config.url : "";
+  const base = typeof config.baseURL === "string" ? config.baseURL : "";
+  if (!base || /^[a-z][a-z\d+\-.]*:\/\//i.test(url)) return url;
+  return `${base.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}`;
+}
+function setAxiosHeaders(config, headers) {
+  const current = config.headers;
+  if (current && typeof current.set === "function") {
+    for (const [name, value] of Object.entries(headers)) current.set(name, value);
+  } else if (current && typeof current === "object") {
+    Object.assign(current, headers);
+  } else {
+    config.headers = { ...headers };
+  }
+}
+function instrumentAxiosInstance(instance, options, getSink) {
+  if (!instance || typeof instance.interceptors?.request?.use !== "function" || typeof instance.interceptors?.response?.use !== "function") {
+    throw new TypeError("instrumentAxios: expected an axios instance (with interceptors.request.use and interceptors.response.use)");
+  }
+  const target = instance;
+  if (target[INSTRUMENTED]) return instance;
+  Object.defineProperty(instance, INSTRUMENTED, { value: true });
+  const calls = /* @__PURE__ */ new WeakMap();
+  const finish = (config, status, error) => {
+    if (typeof config !== "object" || config === null) return;
+    const call = calls.get(config);
+    if (!call) return;
+    calls.delete(config);
+    call.end(status, error);
+  };
+  instance.interceptors.request.use((config) => {
+    try {
+      if (config && typeof config === "object" && !config[INTERNAL_REQUEST2]) {
+        const method = String(config.method ?? "get").toUpperCase();
+        const call = startOutbound(options, getSink, method, safeUrl(axiosUrl(config)));
+        if (call) {
+          setAxiosHeaders(config, call.headers);
+          calls.set(config, call);
+        }
+      }
+    } catch {
+    }
+    return config;
+  });
+  instance.interceptors.response.use(
+    (response) => {
+      finish(response?.config, typeof response?.status === "number" ? response.status : void 0);
+      return response;
+    },
+    (error) => {
+      const status = error?.response?.status;
+      finish(error?.config, typeof status === "number" ? status : void 0, error);
+      return Promise.reject(error);
+    }
+  );
+  return instance;
+}
+
+// src/trace.ts
+function pulsarMixin() {
+  return () => {
+    const ctx = getTraceContext();
+    if (!ctx) return {};
+    const fields = { traceId: ctx.traceId, spanId: ctx.spanId };
+    if (ctx.parentSpanId) fields.parentSpanId = ctx.parentSpanId;
+    return fields;
+  };
+}
+function asError2(value) {
+  return value instanceof Error ? value : new Error(formatArgs([value]));
+}
+function pinoSpanSink(logger) {
+  return (span) => {
+    const entry = spanEntry(span);
+    const record = {
+      traceId: entry.traceId,
+      spanId: entry.spanId,
+      spanKind: entry.spanKind,
+      responseTime: entry.responseTime
+    };
+    if (entry.parentSpanId) record.parentSpanId = entry.parentSpanId;
+    if (entry.method || entry.url) record.req = { method: entry.method, url: entry.url };
+    if (entry.statusCode !== void 0) record.res = { statusCode: entry.statusCode };
+    if (span.error !== void 0) record.err = asError2(span.error);
+    if (entry.metadata) record.metadata = entry.metadata;
+    const level = entry.level;
+    logger[level](record, entry.msg);
+  };
+}
+function startSpan(name, fn, options) {
+  const logger = options?.logger;
+  return runSpan(name, fn, options, logger ? pinoSpanSink(logger) : null);
+}
+function sinkFor(options) {
+  const sink = options.logger ? pinoSpanSink(options.logger) : null;
+  return () => sink;
+}
+function instrumentFetch(first, second) {
+  const fetchImpl = typeof first === "function" ? first : globalThis.fetch;
+  const options = (typeof first === "function" ? second : first) ?? {};
+  return wrapFetch(fetchImpl, options, sinkFor(options));
+}
+function instrumentAxios(instance, options = {}) {
+  return instrumentAxiosInstance(instance, options, sinkFor(options));
+}
+
+// src/index.ts
 var GENERIC_HTTP_MSGS = /* @__PURE__ */ new Set([
   "request completed",
   "request errored",
@@ -59,6 +1366,10 @@ var PINO_INTERNAL_FIELDS = /* @__PURE__ */ new Set([
   "err",
   "metadata"
 ]);
+var SPAN_FIELDS = ["spanId", "parentSpanId", "spanKind"];
+function spanField(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function pickFirst(obj, keys) {
   for (const k of keys) {
     if (obj[k] !== void 0 && obj[k] !== null) return obj[k];
@@ -98,37 +1409,94 @@ var LEVEL_MAP = {
   50: "error",
   60: "fatal"
 };
-var MAX_RETRIES = 3;
-var RETRY_BASE_MS = 1e3;
+var LEVEL_NAMES = new Set(Object.values(LEVEL_MAP));
+function levelName(level) {
+  if (typeof level === "number" && Number.isFinite(level)) {
+    if (LEVEL_MAP[level]) return LEVEL_MAP[level];
+    if (level >= 60) return "fatal";
+    if (level >= 50) return "error";
+    if (level >= 40) return "warn";
+    if (level >= 30) return "info";
+    if (level >= 20) return "debug";
+    return "trace";
+  }
+  if (typeof level === "string") {
+    const lower = level.toLowerCase();
+    if (LEVEL_NAMES.has(lower)) return lower;
+    if (lower === "warning") return "warn";
+    if (/^\d+$/.test(lower)) return levelName(Number(lower));
+  }
+  return "info";
+}
+var SECONDS_THRESHOLD = 1e11;
 function parseTimestamp(time) {
-  if (!time) return Date.now();
-  if (typeof time === "number") return time;
-  if (/^\d{13}$/.test(time)) return parseInt(time, 10);
-  const parsed = new Date(time).getTime();
-  return isNaN(parsed) ? Date.now() : parsed;
+  if (typeof time === "number" && Number.isFinite(time) && time > 0) {
+    return time < SECONDS_THRESHOLD ? Math.round(time * 1e3) : time;
+  }
+  if (typeof time === "string" && time.length > 0) {
+    if (/^\d+(\.\d+)?$/.test(time)) return parseTimestamp(Number(time));
+    const parsed = new Date(time).getTime();
+    if (!isNaN(parsed)) return parsed;
+  }
+  return Date.now();
 }
-async function flushWithRetry(url, apiKey, batch, retryQueue) {
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`
+function asString(value) {
+  if (value === void 0 || value === null) return void 0;
+  return typeof value === "string" ? value : safeStringify(value);
+}
+function toEntry(obj, serviceName) {
+  const method = typeof obj.req?.method === "string" && obj.req.method ? obj.req.method : void 0;
+  const url = typeof obj.req?.url === "string" && obj.req.url ? obj.req.url : void 0;
+  const statusCode = typeof obj.res?.statusCode === "number" && obj.res.statusCode ? obj.res.statusCode : void 0;
+  const usesMessageKey = obj.msg === void 0 && typeof obj.message === "string";
+  let msg = usesMessageKey ? obj.message : asString(obj.msg) ?? "";
+  const lower = msg.toLowerCase().trim();
+  if (GENERIC_HTTP_MSGS.has(lower) && method && url) {
+    msg = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
+  }
+  const extracted = extractPayloads(obj);
+  const baseMeta = isObj(obj.metadata) ? obj.metadata : {};
+  const span = {};
+  for (const key of SPAN_FIELDS) {
+    const value = spanField(obj[key]);
+    if (value) span[key] = value;
+  }
+  const customFields = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (PINO_INTERNAL_FIELDS.has(key) || usesMessageKey && key === "message") continue;
+    if (span[key] !== void 0) continue;
+    if (value !== void 0 && value !== null) customFields[key] = value;
+  }
+  const merged = { ...baseMeta, ...customFields, ...extracted };
+  const metadata = Object.keys(merged).length > 0 ? merged : null;
+  const traceId = obj.traceId || obj.trace_id || obj.requestId || obj.req?.id;
+  const err = isObj(obj.err) ? obj.err : void 0;
+  return {
+    level: levelName(obj.level),
+    msg,
+    timestamp: parseTimestamp(obj.time),
+    serviceName,
+    // pino-http's default request id is a number.
+    traceId: traceId === void 0 || traceId === null || traceId === "" ? null : String(traceId),
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId,
+    spanKind: span.spanKind,
+    method,
+    url,
+    statusCode,
+    responseTime: typeof obj.responseTime === "number" ? obj.responseTime : void 0,
+    errorMessage: asString(err?.message),
+    errorStack: asString(err?.stack),
+    metadata
   };
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    try {
-      const res = await fetch(`${url}/api/ingest/batch`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ logs: batch })
-      });
-      if (res.ok) return;
-      if (res.status >= 400 && res.status < 500) return;
-    } catch {
-    }
-    if (attempt < MAX_RETRIES - 1) {
-      const delay = RETRY_BASE_MS * Math.pow(2, attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
+}
+var PACKAGE_NAME = "@fabbahiense/pulsar-pino-transport";
+function workerOptions(options) {
+  const out = {};
+  for (const key of ["maxBufferSize", "maxRetries", "requestTimeout", "shutdownTimeout", "warnOnDrop"]) {
+    if (options[key] !== void 0) out[key] = options[key];
   }
-  retryQueue.push(...batch);
+  return out;
 }
 function createPulsarTransport(options) {
   const {
@@ -142,8 +1510,8 @@ function createPulsarTransport(options) {
   const resolvedSource = source || serviceName || "default";
   return {
     transport: {
-      target: "@pulsar/pino-transport",
-      options: { url, apiKey, source: resolvedSource, batchSize, flushInterval }
+      target: PACKAGE_NAME,
+      options: { url, apiKey, source: resolvedSource, batchSize, flushInterval, ...workerOptions(options) }
     }
   };
 }
@@ -158,67 +1526,51 @@ async function index_default(options) {
   } = options;
   const resolvedSource = source || serviceName || "default";
   const { default: build } = await import("pino-abstract-transport");
-  const buffer = [];
-  const retryQueue = [];
-  let timer = null;
-  async function flush() {
-    if (retryQueue.length > 0) {
-      buffer.unshift(...retryQueue.splice(0));
-    }
-    if (buffer.length === 0) return;
-    const batch = buffer.splice(0, batchSize);
-    await flushWithRetry(url, apiKey, batch, retryQueue);
-  }
-  return build(async function(stream) {
-    for await (const obj of stream) {
-      const method = obj.req?.method || void 0;
-      const url2 = obj.req?.url || void 0;
-      const statusCode = obj.res?.statusCode || void 0;
-      let msg = obj.msg ?? "";
-      const lower = msg.toLowerCase().trim();
-      if (GENERIC_HTTP_MSGS.has(lower) && method && url2) {
-        msg = `${method.toUpperCase()} ${url2}${statusCode ? ` ${statusCode}` : ""}`;
-      }
-      const extracted = extractPayloads(obj);
-      const baseMeta = isObj(obj.metadata) ? obj.metadata : {};
-      const customFields = {};
-      for (const [key, value] of Object.entries(obj)) {
-        if (!PINO_INTERNAL_FIELDS.has(key) && value !== void 0 && value !== null) {
-          customFields[key] = value;
+  const delivery = new Delivery({
+    url,
+    apiKey,
+    batchSize,
+    flushInterval,
+    maxBufferSize: options.maxBufferSize,
+    maxRetries: options.maxRetries,
+    requestTimeout: options.requestTimeout,
+    shutdownTimeout: options.shutdownTimeout,
+    name: "pulsar-pino-transport",
+    ...options.warnOnDrop === false ? { onDrop: () => {
+    } } : {}
+  });
+  return build(
+    function(source2) {
+      source2.on("data", (obj) => {
+        try {
+          delivery.push(toEntry(obj, resolvedSource));
+        } catch {
         }
-      }
-      const merged = { ...baseMeta, ...customFields, ...extracted };
-      const metadata = Object.keys(merged).length > 0 ? merged : null;
-      buffer.push({
-        level: LEVEL_MAP[obj.level] || "info",
-        msg,
-        timestamp: parseTimestamp(obj.time),
-        serviceName: resolvedSource,
-        traceId: obj.traceId || obj.trace_id || obj.requestId || obj.req?.id || null,
-        method,
-        url: url2,
-        statusCode,
-        responseTime: obj.responseTime,
-        errorMessage: obj.err?.message,
-        errorStack: obj.err?.stack,
-        metadata
       });
-      if (buffer.length >= batchSize) {
-        await flush();
-      }
-      if (!timer) {
-        timer = setInterval(() => flush(), flushInterval);
+    },
+    {
+      // pino-abstract-transport waits for this before emitting 'close', and
+      // pino's worker exits right after 'close', so the final flush has to
+      // happen here (bounded by shutdownTimeout).
+      async close() {
+        await delivery.close();
       }
     }
-    if (timer) clearInterval(timer);
-    await flush();
-    if (retryQueue.length > 0) {
-      buffer.push(...retryQueue.splice(0));
-      await flush();
-    }
-  });
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createPulsarTransport
+  createPulsarTransport,
+  extractTrace,
+  formatTraceparent,
+  getTraceContext,
+  injectTrace,
+  instrumentAxios,
+  instrumentFetch,
+  parseTraceparent,
+  pinoSpanSink,
+  pulsarMixin,
+  runWithTrace,
+  startSpan,
+  traceHeaders
 });