hobots 0.3.0 → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,764 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Client: () => Client,
+  Scope: () => Scope,
+  Span: () => Span,
+  Transaction: () => Transaction,
+  addBreadcrumb: () => addBreadcrumb,
+  captureException: () => captureException,
+  captureMessage: () => captureMessage,
+  checkIn: () => checkIn,
+  close: () => close,
+  flush: () => flush,
+  getClient: () => getClient,
+  init: () => init,
+  parseDsn: () => parseDsn,
+  setContext: () => setContext,
+  setExtra: () => setExtra,
+  setTag: () => setTag,
+  setTags: () => setTags,
+  setUser: () => setUser,
+  startTransaction: () => startTransaction,
+  withMonitor: () => withMonitor,
+  withScope: () => withScope
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/dsn.ts
+function parseDsnUrl(dsn, prefix) {
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}"`);
+  }
+  const key = url.username;
+  const path = url.pathname.replace(/^\/+/, "");
+  if (!key || !path) {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}" \u2014 esperado https://<key>@host/<projeto>`);
+  }
+  return { key, path, origin: `${url.protocol}//${url.host}` };
+}
+function parseDsn(dsn) {
+  const { key, path, origin } = parseDsnUrl(dsn, "[hobots-monitor]");
+  return {
+    publicKey: key,
+    projectId: path,
+    endpoint: `${origin}/api/ingest/${key}`
+  };
+}
+
+// src/stacktrace.ts
+var MAX_FRAMES = 50;
+var FRAME_RE = /^\s*at\s+(?:async\s+)?(?:(.+?)\s+\()?(.+?)\)?$/;
+var LOCATION_RE = /^(.*?):(\d+):(\d+)$/;
+function isInApp(filename) {
+  if (!filename) return false;
+  if (filename.startsWith("node:")) return false;
+  if (filename.startsWith("internal/")) return false;
+  if (filename.includes("node_modules")) return false;
+  if (filename === "<anonymous>") return false;
+  return true;
+}
+function parseStacktrace(stack) {
+  if (!stack) return [];
+  const frames = [];
+  for (const line of stack.split("\n")) {
+    if (frames.length >= MAX_FRAMES) break;
+    const match = FRAME_RE.exec(line);
+    if (!match || !line.trimStart().startsWith("at ")) continue;
+    const [, fn, location] = match;
+    const loc = LOCATION_RE.exec(location ?? "");
+    const filename = loc ? loc[1] : location;
+    frames.push({
+      function: fn || "<anonymous>",
+      filename: filename || void 0,
+      lineno: loc?.[2] ? Number(loc[2]) : void 0,
+      colno: loc?.[3] ? Number(loc[3]) : void 0,
+      in_app: isInApp(filename)
+    });
+  }
+  return frames;
+}
+
+// src/utils.ts
+var SDK_NAME = "hobots";
+var SDK_VERSION = "1.0.0";
+function isNode() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function uuid4() {
+  const cryptoRef = globalThis.crypto;
+  if (cryptoRef && typeof cryptoRef.randomUUID === "function") {
+    return cryptoRef.randomUUID().replace(/-/g, "");
+  }
+  let out = "";
+  for (let i = 0; i < 32; i++) {
+    out += Math.floor(Math.random() * 16).toString(16);
+  }
+  return out;
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function unrefTimer(timer) {
+  timer?.unref?.();
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    unrefTimer(timer);
+  });
+}
+var PREFIX = "[hobots-monitor]";
+function makeLogger(enabled, prefix = PREFIX) {
+  return {
+    debug: (...args) => enabled && console.debug(prefix, ...args),
+    warn: (...args) => enabled && console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args)
+  };
+}
+
+// src/eventbuilder.ts
+function safeString(value) {
+  if (typeof value === "string") return value;
+  try {
+    const json = JSON.stringify(value);
+    if (json && json !== "{}") return json;
+  } catch {
+  }
+  return String(value);
+}
+function eventFromException(error, level = "error") {
+  let type;
+  let value;
+  let frames = [];
+  if (error instanceof Error) {
+    type = error.name || "Error";
+    value = error.message;
+    frames = parseStacktrace(error.stack);
+  } else {
+    type = "NonError";
+    value = safeString(error);
+  }
+  return {
+    event_id: uuid4(),
+    timestamp: nowISO(),
+    level,
+    exception: {
+      type,
+      value,
+      ...frames.length > 0 ? { stacktrace: { frames } } : {}
+    }
+  };
+}
+function eventFromMessage(message, level = "info") {
+  return {
+    event_id: uuid4(),
+    timestamp: nowISO(),
+    level,
+    message
+  };
+}
+
+// src/transport.ts
+var RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_BATCH_SIZE = 10;
+var DEFAULT_MAX_QUEUE_SIZE = 200;
+var Transport = class {
+  endpoint;
+  logger;
+  flushIntervalMs;
+  maxBatchSize;
+  maxQueueSize;
+  buffer = [];
+  timer;
+  pending = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(options) {
+    this.endpoint = options.endpoint;
+    this.logger = options.logger;
+    this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  }
+  enqueue(item) {
+    if (this.closed) {
+      this.logger.warn("transport fechado, item descartado:", item.type);
+      return;
+    }
+    if (this.buffer.length >= this.maxQueueSize) {
+      this.buffer.shift();
+      this.logger.warn("fila cheia, item mais antigo descartado");
+    }
+    this.buffer.push(item);
+    if (this.buffer.length >= this.maxBatchSize) {
+      void this.flushBuffer();
+    } else {
+      this.schedule();
+    }
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.flushBuffer();
+    }, this.flushIntervalMs);
+    unrefTimer(this.timer);
+  }
+  flushBuffer() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    if (this.buffer.length === 0) return Promise.resolve();
+    const items = this.buffer.splice(0, this.buffer.length);
+    const envelope = {
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      sent_at: nowISO(),
+      items
+    };
+    const request = this.sendWithRetry(envelope).finally(() => {
+      this.pending.delete(request);
+    });
+    this.pending.add(request);
+    return request;
+  }
+  async sendWithRetry(envelope) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(envelope)
+        });
+        if (response.ok) {
+          this.logger.debug(`envelope enviado (${envelope.items.length} itens)`);
+          return;
+        }
+        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+          this.logger.error(`envelope rejeitado (HTTP ${response.status}), descartado`);
+          return;
+        }
+        throw new Error(`HTTP ${response.status}`);
+      } catch (error) {
+        const delay = RETRY_DELAYS_MS[attempt];
+        if (delay === void 0) {
+          this.logger.error("envelope descartado ap\xF3s retries:", error);
+          return;
+        }
+        this.logger.warn(`falha no envio (${String(error)}), retry em ${delay}ms`);
+        await sleep(delay);
+      }
+    }
+  }
+  /** Envia o que estiver na fila e aguarda envios em andamento (até timeoutMs). */
+  async flush(timeoutMs = 5e3) {
+    void this.flushBuffer();
+    const all = Promise.allSettled([...this.pending]).then(() => true);
+    return Promise.race([all, sleep(timeoutMs).then(() => false)]);
+  }
+  async close(timeoutMs = 5e3) {
+    const result = await this.flush(timeoutMs);
+    this.closed = true;
+    return result;
+  }
+};
+
+// src/client.ts
+function runtimeContexts() {
+  if (isNode()) {
+    return {
+      runtime: { name: "node", version: process.version },
+      os: { name: process.platform, arch: process.arch }
+    };
+  }
+  return { runtime: { name: "browser" } };
+}
+var Client = class {
+  options;
+  dsn;
+  logger;
+  transport;
+  constructor(options) {
+    this.options = options;
+    this.logger = makeLogger(!!options.debug);
+    this.dsn = parseDsn(options.dsn);
+    this.transport = new Transport({
+      endpoint: this.dsn.endpoint,
+      logger: this.logger,
+      flushIntervalMs: options.flushIntervalMs,
+      maxBatchSize: options.maxBatchSize
+    });
+  }
+  captureException(error, hint, scope2) {
+    return this.captureEvent(eventFromException(error, hint?.level ?? "error"), hint, scope2);
+  }
+  captureMessage(message, level, hint, scope2) {
+    return this.captureEvent(eventFromMessage(message, level), hint, scope2);
+  }
+  captureEvent(event, hint, scope2) {
+    const sampleRate = this.options.sampleRate ?? 1;
+    if (sampleRate < 1 && Math.random() >= sampleRate) {
+      this.logger.debug("evento descartado por sampleRate");
+      return event.event_id;
+    }
+    const prepared = this.prepareEvent(event, hint, scope2);
+    const final = this.options.beforeSend ? this.options.beforeSend(prepared) : prepared;
+    if (!final) {
+      this.logger.debug("evento descartado por beforeSend");
+      return event.event_id;
+    }
+    this.transport.enqueue({ type: "event", payload: final });
+    return final.event_id;
+  }
+  prepareEvent(event, hint, scope2) {
+    const tags = { ...this.options.tags, ...scope2.tags, ...event.tags, ...hint?.tags };
+    const extra = { ...scope2.extra, ...event.extra, ...hint?.extra };
+    return {
+      ...event,
+      level: hint?.level ?? event.level ?? scope2.level ?? "error",
+      release: event.release ?? this.options.release,
+      environment: event.environment ?? this.options.environment ?? "production",
+      server_name: event.server_name ?? this.options.serverName,
+      tags: Object.keys(tags).length > 0 ? tags : void 0,
+      extra: Object.keys(extra).length > 0 ? extra : void 0,
+      user: event.user ?? scope2.user,
+      contexts: { ...runtimeContexts(), ...scope2.contexts, ...event.contexts },
+      breadcrumbs: scope2.breadcrumbs.length > 0 ? [...scope2.breadcrumbs] : event.breadcrumbs,
+      fingerprint: hint?.fingerprint ?? event.fingerprint ?? scope2.fingerprint
+    };
+  }
+  sendTransaction(payload) {
+    this.transport.enqueue({
+      type: "transaction",
+      payload: {
+        ...payload,
+        release: payload.release ?? this.options.release,
+        environment: payload.environment ?? this.options.environment ?? "production",
+        server_name: payload.server_name ?? this.options.serverName,
+        tags: { ...this.options.tags, ...payload.tags }
+      }
+    });
+  }
+  sendCheckIn(payload) {
+    this.transport.enqueue({
+      type: "check_in",
+      payload: {
+        ...payload,
+        environment: payload.environment ?? this.options.environment ?? "production"
+      }
+    });
+  }
+  sendHeartbeat(payload) {
+    this.transport.enqueue({ type: "heartbeat", payload });
+  }
+  flush(timeoutMs) {
+    return this.transport.flush(timeoutMs);
+  }
+  close(timeoutMs) {
+    return this.transport.close(timeoutMs);
+  }
+};
+
+// src/heartbeat.ts
+var DEFAULT_INTERVAL_MS = 3e4;
+function defaultInstanceId() {
+  if (isNode()) {
+    const host = process.env.HOSTNAME || process.env.COMPUTERNAME;
+    if (host) return host;
+  }
+  return `instance-${uuid4().slice(0, 8)}`;
+}
+var Heartbeat = class {
+  constructor(client2, options = {}, serverName) {
+    this.client = client2;
+    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.instanceId = options.instanceId ?? serverName ?? defaultInstanceId();
+    this.name = options.name ?? this.instanceId;
+    this.metadata = options.metadata;
+  }
+  intervalMs;
+  instanceId;
+  name;
+  metadata;
+  timer;
+  start() {
+    if (this.timer) return;
+    this.beat();
+    this.timer = setInterval(() => this.beat(), this.intervalMs);
+    unrefTimer(this.timer);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  beat() {
+    this.client.sendHeartbeat({
+      instance_id: this.instanceId,
+      name: this.name,
+      interval_ms: this.intervalMs,
+      timestamp: nowISO(),
+      metadata: this.metadata
+    });
+  }
+};
+
+// src/instrument.ts
+var installed = false;
+function installGlobalHandlers(client2, getScope) {
+  if (installed) return;
+  installed = true;
+  if (isNode()) {
+    process.on("uncaughtException", (error) => {
+      client2.captureException(error, { level: "fatal", tags: { mechanism: "uncaughtException" } }, getScope());
+      void client2.flush(2e3).then(() => {
+        if (process.listenerCount("uncaughtException") <= 1) {
+          console.error(error);
+          process.exit(1);
+        }
+      });
+    });
+    process.on("unhandledRejection", (reason) => {
+      client2.captureException(reason, { level: "error", tags: { mechanism: "unhandledRejection" } }, getScope());
+      void client2.flush(2e3);
+    });
+    process.on("beforeExit", () => {
+      void client2.flush(2e3);
+    });
+    return;
+  }
+  if (typeof window !== "undefined") {
+    window.addEventListener("error", (event) => {
+      client2.captureException(event.error ?? event.message, { tags: { mechanism: "onerror" } }, getScope());
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      client2.captureException(event.reason, { tags: { mechanism: "onunhandledrejection" } }, getScope());
+    });
+    window.addEventListener("pagehide", () => {
+      void client2.flush(1e3);
+    });
+  }
+}
+
+// src/scope.ts
+var Scope = class _Scope {
+  tags = {};
+  user;
+  contexts = {};
+  extra = {};
+  level;
+  fingerprint;
+  breadcrumbs = [];
+  setTag(key, value) {
+    this.tags[key] = value;
+    return this;
+  }
+  setTags(tags) {
+    Object.assign(this.tags, tags);
+    return this;
+  }
+  setUser(user) {
+    this.user = user ?? void 0;
+    return this;
+  }
+  setContext(name, context) {
+    if (context === null) {
+      delete this.contexts[name];
+    } else {
+      this.contexts[name] = context;
+    }
+    return this;
+  }
+  setExtra(key, value) {
+    this.extra[key] = value;
+    return this;
+  }
+  setExtras(extras) {
+    Object.assign(this.extra, extras);
+    return this;
+  }
+  setLevel(level) {
+    this.level = level;
+    return this;
+  }
+  setFingerprint(fingerprint) {
+    this.fingerprint = fingerprint;
+    return this;
+  }
+  addBreadcrumb(crumb, maxBreadcrumbs) {
+    this.breadcrumbs.push({ timestamp: nowISO(), ...crumb });
+    if (this.breadcrumbs.length > maxBreadcrumbs) {
+      this.breadcrumbs.splice(0, this.breadcrumbs.length - maxBreadcrumbs);
+    }
+    return this;
+  }
+  clearBreadcrumbs() {
+    this.breadcrumbs = [];
+    return this;
+  }
+  clone() {
+    const next = new _Scope();
+    next.tags = { ...this.tags };
+    next.user = this.user ? { ...this.user } : void 0;
+    next.contexts = Object.fromEntries(Object.entries(this.contexts).map(([k, v]) => [k, { ...v }]));
+    next.extra = { ...this.extra };
+    next.level = this.level;
+    next.fingerprint = this.fingerprint ? [...this.fingerprint] : void 0;
+    next.breadcrumbs = [...this.breadcrumbs];
+    return next;
+  }
+};
+
+// src/transaction.ts
+function spanId() {
+  return uuid4().slice(0, 16);
+}
+var Span = class {
+  constructor(transaction, parentSpanId, op, description) {
+    this.transaction = transaction;
+    this.parentSpanId = parentSpanId;
+    this.op = op;
+    this.description = description;
+  }
+  spanId = spanId();
+  startTimestamp = nowISO();
+  status = "ok";
+  endTimestamp;
+  data;
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  setData(key, value) {
+    this.data = { ...this.data, [key]: value };
+    return this;
+  }
+  /** Span aninhado (filho deste span). */
+  startChild(op, description) {
+    return this.transaction.createSpan(this.spanId, op, description);
+  }
+  finish() {
+    if (!this.endTimestamp) this.endTimestamp = nowISO();
+  }
+  toJSON() {
+    return {
+      span_id: this.spanId,
+      parent_span_id: this.parentSpanId,
+      op: this.op,
+      description: this.description,
+      status: this.status,
+      start_timestamp: this.startTimestamp,
+      timestamp: this.endTimestamp ?? nowISO(),
+      data: this.data
+    };
+  }
+};
+var Transaction = class {
+  constructor(client2, name, op, sampled = true) {
+    this.client = client2;
+    this.name = name;
+    this.op = op;
+    this.sampled = sampled;
+  }
+  eventId = uuid4();
+  spanId = spanId();
+  startTimestamp = nowISO();
+  status = "ok";
+  spans = [];
+  tags = {};
+  finished = false;
+  createSpan(parentSpanId, op, description) {
+    const span = new Span(this, parentSpanId, op, description);
+    this.spans.push(span);
+    return span;
+  }
+  /** Span direto da transaction. */
+  startChild(op, description) {
+    return this.createSpan(this.spanId, op, description);
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+    return this;
+  }
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  finish() {
+    if (this.finished) return;
+    this.finished = true;
+    for (const span of this.spans) span.finish();
+    if (!this.sampled || !this.client) return;
+    const payload = {
+      event_id: this.eventId,
+      name: this.name,
+      op: this.op,
+      status: this.status,
+      start_timestamp: this.startTimestamp,
+      timestamp: nowISO(),
+      spans: this.spans.map((span) => span.toJSON()),
+      tags: Object.keys(this.tags).length > 0 ? this.tags : void 0
+    };
+    this.client.sendTransaction(payload);
+  }
+};
+
+// src/checkin.ts
+function sendCheckIn(client2, options) {
+  const checkInId = options.checkInId ?? uuid4();
+  client2.sendCheckIn({
+    check_in_id: checkInId,
+    monitor_slug: options.monitorSlug,
+    status: options.status,
+    duration_ms: options.durationMs,
+    schedule: options.schedule,
+    timezone: options.timezone
+  });
+  return checkInId;
+}
+async function withMonitorImpl(client2, captureError, monitorSlug, fn, options) {
+  const checkInId = sendCheckIn(client2, {
+    monitorSlug,
+    status: "in_progress",
+    schedule: options?.schedule,
+    timezone: options?.timezone
+  });
+  const startedAt = Date.now();
+  try {
+    const result = await fn();
+    sendCheckIn(client2, {
+      monitorSlug,
+      status: "ok",
+      checkInId,
+      durationMs: Date.now() - startedAt,
+      schedule: options?.schedule,
+      timezone: options?.timezone
+    });
+    return result;
+  } catch (error) {
+    sendCheckIn(client2, {
+      monitorSlug,
+      status: "error",
+      checkInId,
+      durationMs: Date.now() - startedAt,
+      schedule: options?.schedule,
+      timezone: options?.timezone
+    });
+    captureError(error);
+    throw error;
+  }
+}
+
+// src/core.ts
+var DEFAULT_MAX_BREADCRUMBS = 100;
+var client;
+var scope = new Scope();
+var heartbeat;
+function init(options) {
+  if (client) {
+    client.logger.warn("init() chamado mais de uma vez \u2014 substituindo o client anterior");
+    heartbeat?.stop();
+    heartbeat = void 0;
+  }
+  client = new Client(options);
+  if (options.captureUnhandled !== false) {
+    installGlobalHandlers(client, () => scope);
+  }
+  if (options.heartbeat) {
+    const heartbeatOptions = options.heartbeat === true ? {} : options.heartbeat;
+    heartbeat = new Heartbeat(client, heartbeatOptions, options.serverName);
+    heartbeat.start();
+  }
+  client.logger.debug("inicializado", { endpoint: client.dsn.endpoint });
+}
+function getClient() {
+  return client;
+}
+function captureException(error, hint) {
+  return client?.captureException(error, hint, scope);
+}
+function captureMessage(message, level = "info", hint) {
+  return client?.captureMessage(message, level, hint, scope);
+}
+function addBreadcrumb(crumb) {
+  scope.addBreadcrumb(crumb, client?.options.maxBreadcrumbs ?? DEFAULT_MAX_BREADCRUMBS);
+}
+function setTag(key, value) {
+  scope.setTag(key, value);
+}
+function setTags(tags) {
+  scope.setTags(tags);
+}
+function setUser(user) {
+  scope.setUser(user);
+}
+function setContext(name, context) {
+  scope.setContext(name, context);
+}
+function setExtra(key, value) {
+  scope.setExtra(key, value);
+}
+function withScope(callback) {
+  const previous = scope;
+  scope = previous.clone();
+  try {
+    return callback(scope);
+  } finally {
+    scope = previous;
+  }
+}
+function startTransaction(name, op) {
+  const rate = client?.options.tracesSampleRate ?? 1;
+  const sampled = rate >= 1 || Math.random() < rate;
+  return new Transaction(client, name, op, sampled);
+}
+function checkIn(options) {
+  return client ? sendCheckIn(client, options) : void 0;
+}
+async function withMonitor(monitorSlug, fn, options) {
+  if (!client) return fn();
+  return withMonitorImpl(
+    client,
+    (error) => captureException(error, { tags: { monitor: monitorSlug } }),
+    monitorSlug,
+    fn,
+    options
+  );
+}
+function flush(timeoutMs) {
+  return client ? client.flush(timeoutMs) : Promise.resolve(true);
+}
+function close(timeoutMs) {
+  heartbeat?.stop();
+  heartbeat = void 0;
+  return client ? client.close(timeoutMs) : Promise.resolve(true);
+}
+//# sourceMappingURL=index.cjs.map