@buenojs/bueno 0.8.4 → 0.8.6

package/dist/telemetry/index.js

@@ -0,0 +1,595 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/telemetry/index.ts
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBase64(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.substring(i, i + 2), 16);
+  }
+  return btoa(String.fromCharCode(...bytes));
+}
+function nowNanoseconds() {
+  return Bun.nanoseconds();
+}
+function toOTLPAttribute(key, value) {
+  if (typeof value === "string") {
+    return { key, value: { stringValue: value } };
+  } else if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return { key, value: { intValue: value } };
+    }
+    return { key, value: { doubleValue: value } };
+  } else if (typeof value === "boolean") {
+    return { key, value: { boolValue: value } };
+  }
+  return { key, value: { stringValue: String(value) } };
+}
+function spanKindToOTLP(kind) {
+  const kindMap = {
+    internal: 1,
+    server: 2,
+    client: 3,
+    producer: 4,
+    consumer: 5
+  };
+  return kindMap[kind] ?? 1;
+}
+function statusCodeToOTLP(code) {
+  const codeMap = {
+    unset: 0,
+    ok: 1,
+    error: 2
+  };
+  return codeMap[code];
+}
+
+class OTLPExporter {
+  endpoint;
+  headers;
+  exportInterval;
+  maxBatchSize;
+  maxRetries;
+  retryDelay;
+  timeout;
+  pendingSpans = [];
+  exportTimer = null;
+  isShuttingDown = false;
+  serviceName = "unknown-service";
+  resourceAttributes = {};
+  constructor(options) {
+    this.endpoint = options.endpoint;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.exportInterval = options.exportInterval ?? 5000;
+    this.maxBatchSize = options.maxBatchSize ?? 100;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelay = options.retryDelay ?? 1000;
+    this.timeout = options.timeout ?? 30000;
+  }
+  setServiceName(name) {
+    this.serviceName = name;
+  }
+  setResourceAttributes(attributes) {
+    this.resourceAttributes = { ...attributes };
+  }
+  start() {
+    if (this.exportTimer !== null)
+      return;
+    this.exportTimer = setInterval(() => {
+      this.flush().catch(() => {});
+    }, this.exportInterval);
+  }
+  stop() {
+    if (this.exportTimer !== null) {
+      clearInterval(this.exportTimer);
+      this.exportTimer = null;
+    }
+  }
+  addSpan(span) {
+    if (this.isShuttingDown)
+      return;
+    this.pendingSpans.push(span);
+    if (this.pendingSpans.length >= this.maxBatchSize) {
+      this.flush().catch(() => {});
+    }
+  }
+  async export(spans) {
+    if (spans.length === 0)
+      return true;
+    const exportRequest = this.buildExportRequest(spans);
+    for (let attempt = 0;attempt < this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController;
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(exportRequest),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          return true;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          console.error(`OTLP export failed with status ${response.status}`);
+          return false;
+        }
+        if (attempt < this.maxRetries - 1) {
+          await this.delay(this.retryDelay * Math.pow(2, attempt));
+        }
+      } catch (error) {
+        if (attempt < this.maxRetries - 1) {
+          await this.delay(this.retryDelay * Math.pow(2, attempt));
+        } else {
+          console.error("OTLP export failed:", error);
+          return false;
+        }
+      }
+    }
+    return false;
+  }
+  async flush() {
+    if (this.pendingSpans.length === 0)
+      return;
+    const spansToExport = [...this.pendingSpans];
+    this.pendingSpans = [];
+    await this.export(spansToExport);
+  }
+  async close() {
+    this.isShuttingDown = true;
+    this.stop();
+    await this.flush();
+  }
+  buildExportRequest(spans) {
+    const resourceAttributes = [
+      toOTLPAttribute("service.name", this.serviceName)
+    ];
+    for (const [key, value] of Object.entries(this.resourceAttributes)) {
+      resourceAttributes.push(toOTLPAttribute(key, value));
+    }
+    const otlpSpans = spans.map((span) => ({
+      traceId: hexToBase64(span.traceId),
+      spanId: hexToBase64(span.spanId),
+      parentSpanId: span.parentSpanId ? hexToBase64(span.parentSpanId) : undefined,
+      name: span.name,
+      kind: spanKindToOTLP(span.kind),
+      startTimeUnixNano: span.startTime,
+      endTimeUnixNano: span.endTime ?? span.startTime,
+      attributes: Object.entries(span.attributes).map(([k, v]) => toOTLPAttribute(k, v)),
+      events: span.events.map((event) => ({
+        timeUnixNano: event.timestamp,
+        name: event.name,
+        attributes: event.attributes ? Object.entries(event.attributes).map(([k, v]) => toOTLPAttribute(k, v)) : []
+      })),
+      status: {
+        code: statusCodeToOTLP(span.status.code),
+        message: span.status.message
+      }
+    }));
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: resourceAttributes
+          },
+          scopeSpans: [
+            {
+              scope: { name: "bueno-tracer" },
+              spans: otlpSpans
+            }
+          ]
+        }
+      ]
+    };
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+class Tracer {
+  serviceName;
+  exporter;
+  sampler;
+  probability;
+  resourceAttributes;
+  currentSpan = null;
+  spanStack = [];
+  constructor(options = {}) {
+    this.serviceName = options.serviceName ?? "unknown-service";
+    this.exporter = options.exporter;
+    this.sampler = options.sampler ?? "always";
+    this.probability = options.probability ?? 1;
+    this.resourceAttributes = options.resourceAttributes ?? {};
+    if (this.exporter) {
+      this.exporter.setServiceName(this.serviceName);
+      this.exporter.setResourceAttributes(this.resourceAttributes);
+      this.exporter.start();
+    }
+  }
+  shouldSample() {
+    switch (this.sampler) {
+      case "always":
+        return true;
+      case "never":
+        return false;
+      case "probabilistic":
+        return Math.random() < this.probability;
+      default:
+        return true;
+    }
+  }
+  startSpan(name, options = {}) {
+    if (!this.shouldSample()) {
+      return this.createNoopSpan(name, options);
+    }
+    const parent = options.parent ?? this.currentSpan;
+    const span = {
+      traceId: parent?.traceId ?? generateTraceId(),
+      spanId: generateSpanId(),
+      parentSpanId: parent?.spanId,
+      name,
+      kind: options.kind ?? "internal",
+      startTime: options.startTime ?? nowNanoseconds(),
+      attributes: { ...options.attributes },
+      events: [],
+      status: { code: "unset" },
+      ended: false
+    };
+    return span;
+  }
+  endSpan(span, endTime) {
+    if (span.ended)
+      return;
+    span.ended = true;
+    span.endTime = endTime ?? nowNanoseconds();
+    span.duration = span.endTime - span.startTime;
+    if (this.exporter) {
+      this.exporter.addSpan(span);
+    }
+  }
+  getCurrentSpan() {
+    return this.currentSpan;
+  }
+  async withSpan(name, fn, options = {}) {
+    const span = this.startSpan(name, options);
+    const previousSpan = this.currentSpan;
+    this.currentSpan = span;
+    this.spanStack.push(span);
+    try {
+      const result = await fn(span);
+      return result;
+    } catch (error) {
+      this.setError(span, error);
+      throw error;
+    } finally {
+      this.endSpan(span);
+      this.spanStack.pop();
+      this.currentSpan = previousSpan ?? this.spanStack[this.spanStack.length - 1] ?? null;
+    }
+  }
+  addEvent(span, name, attributes) {
+    if (span.ended)
+      return;
+    span.events.push({
+      name,
+      timestamp: nowNanoseconds(),
+      attributes
+    });
+  }
+  setAttribute(span, key, value) {
+    if (span.ended)
+      return;
+    span.attributes[key] = value;
+  }
+  setAttributes(span, attributes) {
+    if (span.ended)
+      return;
+    Object.assign(span.attributes, attributes);
+  }
+  setStatus(span, code, message) {
+    if (span.ended)
+      return;
+    span.status = { code, message };
+  }
+  setError(span, error) {
+    if (span.ended)
+      return;
+    span.status = {
+      code: "error",
+      message: error.message
+    };
+    span.events.push({
+      name: "exception",
+      timestamp: nowNanoseconds(),
+      attributes: {
+        "exception.type": error.name,
+        "exception.message": error.message,
+        "exception.stacktrace": error.stack ?? ""
+      }
+    });
+  }
+  updateName(span, name) {
+    if (span.ended)
+      return;
+    span.name = name;
+  }
+  injectContext(carrier, span) {
+    const activeSpan = span ?? this.currentSpan;
+    if (!activeSpan)
+      return;
+    const traceFlags = activeSpan.status.code === "error" ? 0 : 1;
+    const traceparent = `00-${activeSpan.traceId}-${activeSpan.spanId}-${traceFlags.toString(16).padStart(2, "0")}`;
+    carrier["traceparent"] = traceparent;
+  }
+  extractContext(carrier) {
+    const traceparent = carrier["traceparent"] ?? carrier["Traceparent"];
+    if (!traceparent)
+      return null;
+    const parts = traceparent.split("-");
+    if (parts.length !== 4)
+      return null;
+    const [version, traceId, spanId, flags] = parts;
+    if (version !== "00")
+      return null;
+    if (!/^[0-9a-f]{32}$/i.test(traceId))
+      return null;
+    if (!/^[0-9a-f]{16}$/i.test(spanId))
+      return null;
+    return {
+      traceId,
+      spanId,
+      traceFlags: Number.parseInt(flags, 16),
+      traceState: carrier["tracestate"] ?? carrier["Tracestate"]
+    };
+  }
+  startSpanFromContext(name, context, options = {}) {
+    return this.startSpan(name, {
+      ...options,
+      parent: {
+        traceId: context.traceId,
+        spanId: context.spanId
+      }
+    });
+  }
+  async flush() {
+    if (this.exporter) {
+      await this.exporter.flush();
+    }
+  }
+  async close() {
+    if (this.exporter) {
+      await this.exporter.close();
+    }
+  }
+  createNoopSpan(name, options) {
+    return {
+      traceId: generateTraceId(),
+      spanId: generateSpanId(),
+      parentSpanId: options.parent?.spanId,
+      name,
+      kind: options.kind ?? "internal",
+      startTime: options.startTime ?? nowNanoseconds(),
+      attributes: {},
+      events: [],
+      status: { code: "unset" },
+      ended: false
+    };
+  }
+}
+function createTracer(serviceName, options = {}) {
+  return new Tracer({
+    ...options,
+    serviceName
+  });
+}
+function traceMiddleware(tracer) {
+  return async (ctx, next) => {
+    const headers = {};
+    for (const [key, value] of Object.entries(ctx.headers)) {
+      headers[key.toLowerCase()] = value;
+    }
+    const parentContext = tracer.extractContext(headers);
+    const spanOptions = {
+      kind: "server",
+      attributes: {
+        "http.method": ctx.method,
+        "http.url": ctx.url?.toString() ?? ctx.path,
+        "http.route": ctx.path
+      }
+    };
+    let span;
+    if (parentContext) {
+      span = tracer.startSpanFromContext(`${ctx.method} ${ctx.path}`, parentContext, spanOptions);
+    } else {
+      span = tracer.startSpan(`${ctx.method} ${ctx.path}`, spanOptions);
+    }
+    const outgoingHeaders = {};
+    tracer.injectContext(outgoingHeaders, span);
+    for (const [key, value] of Object.entries(outgoingHeaders)) {
+      ctx.setHeader(key, value);
+    }
+    try {
+      const response = await next();
+      tracer.setAttribute(span, "http.status_code", response.status);
+      if (response.status >= 400) {
+        tracer.setStatus(span, "error");
+      } else {
+        tracer.setStatus(span, "ok");
+      }
+      return response;
+    } catch (error) {
+      tracer.setError(span, error);
+      throw error;
+    } finally {
+      tracer.endSpan(span);
+    }
+  };
+}
+function traceDatabase(tracer, db, system = "unknown") {
+  const tracedDb = { ...db };
+  if (typeof db.query === "function") {
+    const originalQuery = db.query.bind(db);
+    tracedDb.query = async (sql, params) => {
+      return tracer.withSpan(`db.query`, async (span) => {
+        tracer.setAttributes(span, {
+          "db.system": system,
+          "db.statement": sql,
+          "db.operation": extractOperation(sql)
+        });
+        if (params) {
+          tracer.setAttribute(span, "db.params", JSON.stringify(params));
+        }
+        const result = await originalQuery(sql, params);
+        tracer.setStatus(span, "ok");
+        return result;
+      }, { kind: "client" });
+    };
+  }
+  if (typeof db.execute === "function") {
+    const originalExecute = db.execute.bind(db);
+    tracedDb.execute = async (sql, params) => {
+      return tracer.withSpan(`db.execute`, async (span) => {
+        tracer.setAttributes(span, {
+          "db.system": system,
+          "db.statement": sql,
+          "db.operation": extractOperation(sql)
+        });
+        if (params) {
+          tracer.setAttribute(span, "db.params", JSON.stringify(params));
+        }
+        const result = await originalExecute(sql, params);
+        tracer.setStatus(span, "ok");
+        return result;
+      }, { kind: "client" });
+    };
+  }
+  return tracedDb;
+}
+function extractOperation(sql) {
+  const normalized = sql.trim().toUpperCase();
+  const match = normalized.match(/^(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE)/);
+  return match ? match[1] : "UNKNOWN";
+}
+function createTracedFetch(tracer) {
+  return async (url, options = {}) => {
+    const { parentSpan, attributes = {}, ...fetchOptions } = options;
+    const urlStr = url.toString();
+    return tracer.withSpan(`HTTP ${fetchOptions.method ?? "GET"}`, async (span) => {
+      tracer.setAttributes(span, {
+        "http.method": fetchOptions.method ?? "GET",
+        "http.url": urlStr,
+        ...attributes
+      });
+      const headers = new Headers(fetchOptions.headers);
+      const carrier = {};
+      tracer.injectContext(carrier, span);
+      for (const [key, value] of Object.entries(carrier)) {
+        headers.set(key, value);
+      }
+      try {
+        const response = await fetch(url, {
+          ...fetchOptions,
+          headers
+        });
+        tracer.setAttribute(span, "http.status_code", response.status);
+        tracer.setStatus(span, response.status >= 400 ? "error" : "ok");
+        return response;
+      } catch (error) {
+        tracer.setError(span, error);
+        throw error;
+      }
+    }, { kind: "client", parent: parentSpan });
+  };
+}
+
+class SpanBuilder {
+  span;
+  tracer;
+  constructor(tracer, name, options = {}) {
+    this.tracer = tracer;
+    this.span = tracer.startSpan(name, options);
+  }
+  setAttribute(key, value) {
+    this.tracer.setAttribute(this.span, key, value);
+    return this;
+  }
+  setAttributes(attributes) {
+    this.tracer.setAttributes(this.span, attributes);
+    return this;
+  }
+  addEvent(name, attributes) {
+    this.tracer.addEvent(this.span, name, attributes);
+    return this;
+  }
+  setStatus(code, message) {
+    this.tracer.setStatus(this.span, code, message);
+    return this;
+  }
+  setError(error) {
+    this.tracer.setError(this.span, error);
+    return this;
+  }
+  end() {
+    this.tracer.endSpan(this.span);
+    return this.span;
+  }
+  getSpan() {
+    return this.span;
+  }
+}
+function span(tracer, name, options = {}) {
+  return new SpanBuilder(tracer, name, options);
+}
+export {
+  traceMiddleware,
+  traceDatabase,
+  span,
+  nowNanoseconds,
+  generateTraceId,
+  generateSpanId,
+  createTracer,
+  createTracedFetch,
+  Tracer,
+  SpanBuilder,
+  OTLPExporter
+};