traza-log 0.1.0

package/dist/index.cjs

@@ -0,0 +1,735 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/runtime.ts
+function detectRuntime() {
+  if (typeof Bun !== "undefined") return "bun";
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof EdgeRuntime !== "undefined") return "edge";
+  if (typeof process !== "undefined" && process.versions?.node) return "node";
+  if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+  return "unknown";
+}
+var RUNTIME = detectRuntime();
+var IS_NODE_LIKE = RUNTIME === "node" || RUNTIME === "bun" || RUNTIME === "deno";
+
+// src/context.ts
+var FallbackContextStore = class {
+  current;
+  getActive() {
+    return this.current;
+  }
+  run(ctx, fn) {
+    const prev = this.current;
+    this.current = ctx;
+    try {
+      const result = fn();
+      if (result instanceof Promise) {
+        return result.finally(() => {
+          this.current = prev;
+        });
+      }
+      this.current = prev;
+      return result;
+    } catch (e) {
+      this.current = prev;
+      throw e;
+    }
+  }
+};
+var AlsContextStore = class {
+  als;
+  constructor(Als) {
+    this.als = new Als();
+  }
+  getActive() {
+    return this.als.getStore();
+  }
+  run(ctx, fn) {
+    return this.als.run(ctx, fn);
+  }
+};
+var storeInstance;
+function getStore() {
+  if (storeInstance) return storeInstance;
+  if (IS_NODE_LIKE) {
+    try {
+      const req = Function("return require")();
+      const mod = req ? req("node:async_hooks") : void 0;
+      if (mod?.AsyncLocalStorage) {
+        storeInstance = new AlsContextStore(mod.AsyncLocalStorage);
+        return storeInstance;
+      }
+    } catch {
+    }
+  }
+  storeInstance = new FallbackContextStore();
+  return storeInstance;
+}
+function getActiveContext() {
+  return getStore().getActive();
+}
+function runWithContext(ctx, fn) {
+  return getStore().run(ctx, fn);
+}
+function mergeContext(base, patch) {
+  return {
+    traceId: patch.traceId ?? base?.traceId,
+    spanId: patch.spanId ?? base?.spanId,
+    parentSpanId: patch.parentSpanId ?? base?.parentSpanId,
+    attributes: { ...base?.attributes ?? {}, ...patch.attributes ?? {} }
+  };
+}
+
+// src/utils.ts
+var HEX = "0123456789abcdef";
+function randomHex(bytes) {
+  const buf = new Uint8Array(bytes);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) {
+    c.getRandomValues(buf);
+  } else {
+    for (let i = 0; i < bytes; i++) buf[i] = Math.floor(Math.random() * 256);
+  }
+  let out = "";
+  for (let i = 0; i < bytes; i++) {
+    const v = buf[i];
+    out += HEX[v >> 4] + HEX[v & 15];
+  }
+  return out;
+}
+function newTraceId() {
+  return randomHex(16);
+}
+function newSpanId() {
+  return randomHex(8);
+}
+function newEventId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (c?.getRandomValues) c.getRandomValues(b);
+  else for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = (n) => HEX[n >> 4 & 15] + HEX[n & 15];
+  return h(b[0]) + h(b[1]) + h(b[2]) + h(b[3]) + "-" + h(b[4]) + h(b[5]) + "-" + h(b[6]) + h(b[7]) + "-" + h(b[8]) + h(b[9]) + "-" + h(b[10]) + h(b[11]) + h(b[12]) + h(b[13]) + h(b[14]) + h(b[15]);
+}
+function now() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.timeOrigin + performance.now();
+  }
+  return Date.now();
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_k, v) => {
+      if (typeof v === "bigint") return v.toString();
+      if (typeof v === "object" && v !== null) {
+        if (seen.has(v)) return "[Circular]";
+        seen.add(v);
+      }
+      if (v instanceof Error) {
+        return { name: v.name, message: v.message, stack: v.stack };
+      }
+      return v;
+    });
+  } catch {
+    return String(value);
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function normalizeError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  if (typeof err === "string") return { message: err };
+  if (isPlainObject(err)) {
+    return {
+      name: typeof err.name === "string" ? err.name : void 0,
+      message: typeof err.message === "string" ? err.message : safeStringify(err),
+      stack: typeof err.stack === "string" ? err.stack : void 0
+    };
+  }
+  return { message: safeStringify(err) };
+}
+
+// src/middleware.ts
+function createHttpMiddleware(client) {
+  return function trazaMiddleware(req, res, next) {
+    const method = req.method ?? "GET";
+    const url = req.originalUrl ?? req.url ?? "/";
+    const traceparent = pickHeader(req.headers, "traceparent");
+    const parent = parseTraceparent(traceparent);
+    const route = stripQuery(url);
+    const span = client.startSpan(`HTTP ${method}`, {
+      attributes: {
+        "http.method": method,
+        "http.url": url,
+        "http.route": route,
+        "http.user_agent": pickHeader(req.headers, "user-agent")
+      },
+      parent
+    });
+    client.runWithContext(
+      {
+        traceId: span.traceId,
+        spanId: span.id,
+        attributes: { "http.method": method, "http.route": route }
+      },
+      () => {
+        let finished = false;
+        const finish = (err) => {
+          if (finished) return;
+          finished = true;
+          const status = res.statusCode ?? 0;
+          span.setAttribute("http.status_code", status);
+          if (err) span.recordError(err);
+          span.end({
+            status: err || status >= 500 ? "error" : "ok",
+            error: err
+          });
+        };
+        try {
+          res.on?.("finish", () => finish());
+          res.on?.("close", () => finish());
+        } catch {
+        }
+        try {
+          next();
+        } catch (e) {
+          finish(e);
+          throw e;
+        }
+      }
+    );
+  };
+}
+function wrapH3Handler(client, handler, name) {
+  return (async (...args) => {
+    const event = args[0];
+    const req = event?.node?.req;
+    const res = event?.node?.res;
+    const method = event?.method ?? req?.method ?? "GET";
+    const url = event?.path ?? req?.url ?? "/";
+    const parent = parseTraceparent(pickHeader(req?.headers, "traceparent"));
+    const span = client.startSpan(name ?? `HTTP ${method} ${stripQuery(url)}`, {
+      attributes: { "http.method": method, "http.url": url, "http.route": stripQuery(url) },
+      parent
+    });
+    try {
+      return await client.runWithContext(
+        { traceId: span.traceId, spanId: span.id, attributes: {} },
+        () => handler(...args)
+      );
+    } catch (err) {
+      span.recordError(err);
+      throw err;
+    } finally {
+      span.setAttribute("http.status_code", res?.statusCode ?? 0);
+      span.end({ status: (res?.statusCode ?? 0) >= 500 ? "error" : "ok" });
+    }
+  });
+}
+function pickHeader(headers, name) {
+  if (!headers) return void 0;
+  const v = headers[name] ?? headers[name.toLowerCase()];
+  if (Array.isArray(v)) return v[0];
+  return v;
+}
+function stripQuery(url) {
+  const i = url.indexOf("?");
+  return i === -1 ? url : url.slice(0, i);
+}
+function parseTraceparent(value) {
+  if (!value) return void 0;
+  const parts = value.split("-");
+  if (parts.length < 4) return void 0;
+  const traceId = parts[1];
+  const spanId = parts[2];
+  if (!traceId || traceId.length !== 32 || !spanId || spanId.length !== 16) return void 0;
+  return { traceId, spanId };
+}
+
+// src/queue.ts
+var BoundedQueue = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  buffer = [];
+  get size() {
+    return this.buffer.length;
+  }
+  enqueue(event) {
+    if (this.buffer.length >= this.opts.maxSize) {
+      const dropped = this.buffer.shift();
+      if (dropped && this.opts.onDrop) {
+        try {
+          this.opts.onDrop(dropped);
+        } catch {
+        }
+      }
+    }
+    this.buffer.push(event);
+  }
+  drain(max) {
+    if (max <= 0 || this.buffer.length === 0) return [];
+    if (max >= this.buffer.length) {
+      const all = this.buffer;
+      this.buffer = [];
+      return all;
+    }
+    return this.buffer.splice(0, max);
+  }
+  prepend(events) {
+    if (events.length === 0) return;
+    const overflow = this.buffer.length + events.length - this.opts.maxSize;
+    if (overflow > 0) {
+      const drop = this.buffer.splice(this.buffer.length - overflow, overflow);
+      if (this.opts.onDrop) drop.forEach((d) => this.opts.onDrop(d));
+    }
+    this.buffer = events.concat(this.buffer);
+  }
+};
+
+// src/transport.ts
+var SDK_NAME = "traza";
+var SDK_VERSION = "0.1.0";
+var DEFAULTS = {
+  flushIntervalMs: 3e3,
+  maxBatchSize: 100,
+  maxQueueSize: 1e4,
+  requestTimeoutMs: 1e4,
+  maxRetries: 3
+};
+var BatchTransport = class {
+  constructor(deps) {
+    this.deps = deps;
+    const max = deps.config.maxQueueSize ?? DEFAULTS.maxQueueSize;
+    this.queue = new BoundedQueue({ maxSize: max });
+    this.endpoint = normalizeEndpoint(deps.config.endpoint);
+    const f = deps.config.fetch ?? globalThis.fetch;
+    if (!f) {
+      throw new Error(
+        "[traza] No fetch implementation found. Pass `fetch` in config or upgrade to Node 18+."
+      );
+    }
+    this.fetchImpl = f.bind(globalThis);
+    this.startTimer();
+    this.attachShutdownHooks();
+  }
+  deps;
+  queue;
+  timer = null;
+  flushing = false;
+  stopped = false;
+  endpoint;
+  fetchImpl;
+  push(event) {
+    if (this.stopped) return;
+    this.queue.enqueue(event);
+    const max = this.deps.config.maxBatchSize ?? DEFAULTS.maxBatchSize;
+    if (this.queue.size >= max) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.flushing) return;
+    this.flushing = true;
+    try {
+      const batchSize = this.deps.config.maxBatchSize ?? DEFAULTS.maxBatchSize;
+      let batch = this.queue.drain(batchSize);
+      while (batch.length > 0) {
+        const ok = await this.send(batch);
+        if (!ok) {
+          this.queue.prepend(batch);
+          break;
+        }
+        batch = this.queue.drain(batchSize);
+      }
+    } catch (e) {
+      this.deps.onError(e);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async shutdown() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  async send(events) {
+    const payload = {
+      sdk: { name: SDK_NAME, version: SDK_VERSION, runtime: RUNTIME },
+      sentAt: Date.now(),
+      events
+    };
+    const body = JSON.stringify(payload);
+    const timeoutMs = this.deps.config.requestTimeoutMs ?? DEFAULTS.requestTimeoutMs;
+    for (let attempt = 0; attempt <= DEFAULTS.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const res = await this.fetchImpl(`${this.endpoint}/api/ingest`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.deps.config.token}`,
+            "x-traza-sdk": `${SDK_NAME}/${SDK_VERSION}`,
+            "x-traza-runtime": RUNTIME
+          },
+          body,
+          signal: controller.signal,
+          keepalive: events.length < 50
+          // browsers permiten keepalive en payloads pequeños
+        });
+        clearTimeout(timer);
+        if (res.ok) return true;
+        if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+          this.deps.onError(new Error(`[traza] ingest rejected: ${res.status} ${res.statusText}`));
+          return true;
+        }
+      } catch (e) {
+        clearTimeout(timer);
+        if (attempt === DEFAULTS.maxRetries) {
+          this.deps.onError(e);
+          return false;
+        }
+      }
+      await delay(backoffMs(attempt));
+    }
+    return false;
+  }
+  startTimer() {
+    const interval = this.deps.config.flushIntervalMs ?? DEFAULTS.flushIntervalMs;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, interval);
+    const t = this.timer;
+    if (typeof t.unref === "function") t.unref();
+  }
+  attachShutdownHooks() {
+    if (typeof process !== "undefined" && typeof process.on === "function") {
+      const handler = () => {
+        void this.flush();
+      };
+      try {
+        process.on("beforeExit", handler);
+      } catch {
+      }
+    }
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      const handler = () => {
+        void this.flush();
+      };
+      try {
+        window.addEventListener("pagehide", handler);
+        document.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "hidden") handler();
+        });
+      } catch {
+      }
+    }
+  }
+};
+function backoffMs(attempt) {
+  const base = 200 * Math.pow(2, attempt);
+  const jitter = Math.random() * base * 0.3;
+  return Math.min(base + jitter, 5e3);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeEndpoint(url) {
+  return url.replace(/\/+$/, "");
+}
+
+// src/span.ts
+var SpanImpl = class {
+  constructor(input, deps) {
+    this.deps = deps;
+    this.name = input.name;
+    this.attributes = { ...input.attributes ?? {} };
+    this.contextSnapshot = input.parentContext?.attributes;
+    if (input.parentOverride) {
+      this.traceId = input.parentOverride.traceId;
+      this.parentSpanId = input.parentOverride.spanId;
+    } else if (input.parentContext?.traceId) {
+      this.traceId = input.parentContext.traceId;
+      this.parentSpanId = input.parentContext.spanId;
+    } else {
+      this.traceId = newTraceId();
+    }
+    this.id = newSpanId();
+    this.startTime = now();
+  }
+  deps;
+  id;
+  traceId;
+  parentSpanId;
+  name;
+  startTime;
+  attributes;
+  contextSnapshot;
+  status = "ok";
+  errorInfo;
+  endedFlag = false;
+  get ended() {
+    return this.endedFlag;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+  setAttributes(attributes) {
+    Object.assign(this.attributes, attributes);
+    return this;
+  }
+  recordError(error) {
+    this.status = "error";
+    this.errorInfo = normalizeError(error);
+    return this;
+  }
+  end(options = {}) {
+    if (this.endedFlag) return;
+    this.endedFlag = true;
+    if (options.attributes) Object.assign(this.attributes, options.attributes);
+    if (options.error) {
+      this.status = options.status ?? "error";
+      this.errorInfo = normalizeError(options.error);
+    } else if (options.status) {
+      this.status = options.status;
+    }
+    const endTime = now();
+    const event = {
+      type: "span",
+      id: this.id,
+      traceId: this.traceId,
+      parentSpanId: this.parentSpanId,
+      name: this.name,
+      status: this.status,
+      startTime: this.startTime,
+      endTime,
+      durationMs: Math.max(0, endTime - this.startTime),
+      attributes: { ...this.deps.defaultAttributes ?? {}, ...this.attributes },
+      error: this.errorInfo,
+      service: this.deps.service,
+      environment: this.deps.environment,
+      release: this.deps.release,
+      context: this.contextSnapshot
+    };
+    this.deps.onEnd(event);
+  }
+};
+
+// src/client.ts
+var noop = () => {
+};
+var CONSOLE_METHOD = {
+  debug: "debug",
+  info: "info",
+  log: "log",
+  warn: "warn",
+  error: "error"
+};
+var TrazaClient = class {
+  transport = null;
+  config = null;
+  configure(config) {
+    if (!config.token) throw new Error("[traza] config.token is required");
+    if (!config.endpoint) throw new Error("[traza] config.endpoint is required");
+    if (this.transport) {
+      void this.transport.shutdown();
+    }
+    this.config = config;
+    const onError = config.onError ?? (config.debug ? console.error.bind(console) : noop);
+    this.transport = new BatchTransport({ config, onError });
+    return this;
+  }
+  isConfigured() {
+    return this.transport !== null;
+  }
+  /** Cierra el transport y vacía la cola. Útil en tests y al apagar el proceso. */
+  async shutdown() {
+    if (this.transport) {
+      await this.transport.shutdown();
+      this.transport = null;
+    }
+  }
+  /** Fuerza el envío inmediato del lote en cola. */
+  async flush() {
+    await this.transport?.flush();
+  }
+  // --- Logs ---
+  debug(message, attributes) {
+    this.emitLog("debug", message, attributes);
+  }
+  info(message, attributes) {
+    this.emitLog("info", message, attributes);
+  }
+  log(message, attributes) {
+    this.emitLog("log", message, attributes);
+  }
+  warn(message, attributes) {
+    this.emitLog("warn", message, attributes);
+  }
+  error(message, attributes) {
+    this.emitLog("error", message, attributes);
+  }
+  // --- Spans ---
+  startSpan(name, options = {}) {
+    const ctx = options.detached ? void 0 : getActiveContext();
+    return new SpanImpl(
+      {
+        name,
+        attributes: options.attributes,
+        parentContext: ctx,
+        parentOverride: options.parent
+      },
+      {
+        service: this.config?.service,
+        environment: this.config?.environment,
+        release: this.config?.release,
+        defaultAttributes: this.config?.defaultAttributes,
+        onEnd: (event) => this.push(event)
+      }
+    );
+  }
+  /** Mide la duración de una función async y la reporta como span. */
+  async time(name, fn, attributes) {
+    const span = this.startSpan(name, { attributes });
+    try {
+      const result = await this.runWithContext(
+        { traceId: span.traceId, spanId: span.id, attributes: {} },
+        () => Promise.resolve(fn())
+      );
+      span.end({ status: "ok" });
+      return result;
+    } catch (err) {
+      span.recordError(err);
+      span.end({ status: "error", error: err });
+      throw err;
+    }
+  }
+  /** Envuelve una función para que cada llamada quede instrumentada. */
+  instrument(name, fn, attributesFactory) {
+    return async (...args) => {
+      const attrs = attributesFactory ? attributesFactory(...args) : void 0;
+      return this.time(name, () => fn(...args), attrs);
+    };
+  }
+  // --- Contexto ---
+  /** Ejecuta `fn` dentro de un contexto activo. Logs/spans hijos lo heredan. */
+  runWithContext(patch, fn) {
+    const merged = mergeContext(getActiveContext(), patch);
+    return runWithContext(merged, fn);
+  }
+  /** Devuelve una copia del contexto actual (útil para propagación manual). */
+  getContext() {
+    return getActiveContext();
+  }
+  // --- Integraciones ---
+  middleware() {
+    return createHttpMiddleware(this);
+  }
+  h3(handler, name) {
+    return wrapH3Handler(this, handler, name);
+  }
+  // --- Privados ---
+  emitLog(level, message, attributes) {
+    const ctx = getActiveContext();
+    const event = {
+      type: "log",
+      id: newEventId(),
+      level,
+      message,
+      attributes: this.mergeAttributes(attributes, level === "error" ? this.errorFromAttrs(attributes) : void 0),
+      timestamp: now(),
+      service: this.config?.service,
+      environment: this.config?.environment,
+      release: this.config?.release,
+      traceId: ctx?.traceId,
+      spanId: ctx?.spanId,
+      parentSpanId: ctx?.parentSpanId,
+      context: ctx?.attributes
+    };
+    if (this.config?.forwardToConsole !== false) {
+      this.forwardConsole(level, message, attributes);
+    }
+    this.push(event);
+  }
+  errorFromAttrs(attrs) {
+    if (!attrs) return void 0;
+    const err = attrs.err ?? attrs.error;
+    if (err instanceof Error || typeof err === "object" && err !== null && "message" in err) {
+      const norm = normalizeError(err);
+      return {
+        "error.name": norm.name ?? null,
+        "error.message": norm.message ?? null,
+        "error.stack": norm.stack ?? null
+      };
+    }
+    return void 0;
+  }
+  mergeAttributes(...parts) {
+    const out = { ...this.config?.defaultAttributes ?? {} };
+    let has = Object.keys(out).length > 0;
+    for (const p of parts) {
+      if (!p) continue;
+      for (const [k, v] of Object.entries(p)) {
+        out[k] = v;
+        has = true;
+      }
+    }
+    return has ? out : void 0;
+  }
+  forwardConsole(level, message, attributes) {
+    if (typeof console === "undefined") return;
+    const method = CONSOLE_METHOD[level];
+    const fn = console[method];
+    if (typeof fn !== "function") return;
+    if (attributes && Object.keys(attributes).length > 0) {
+      fn.call(console, `[traza] ${message}`, attributes);
+    } else {
+      fn.call(console, `[traza] ${message}`);
+    }
+  }
+  push(event) {
+    if (!this.transport) {
+      if (this.config?.debug) {
+        console.warn("[traza] no configurado; evento descartado");
+      }
+      return;
+    }
+    const rate = this.config?.sampleRate ?? 1;
+    if (rate < 1 && Math.random() > rate) return;
+    this.transport.push(event);
+  }
+};
+
+// src/index.ts
+var traza = new TrazaClient();
+function createTraza() {
+  return new TrazaClient();
+}
+var index_default = traza;
+
+exports.RUNTIME = RUNTIME;
+exports.TrazaClient = TrazaClient;
+exports.createTraza = createTraza;
+exports.default = index_default;
+exports.detectRuntime = detectRuntime;
+exports.getActiveContext = getActiveContext;
+exports.runWithContext = runWithContext;
+exports.traza = traza;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map