@arcote.tech/arc-otel 0.7.6

package/dist/init-browser.js

@@ -0,0 +1,326 @@
+// src/init-browser.ts
+import { propagation as propagation2 } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import {
+  BatchSpanProcessor,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-base";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import {
+  ATTR_DEPLOYMENT_ENVIRONMENT_NAME,
+  ATTR_SERVICE_NAME
+} from "@opentelemetry/semantic-conventions/incubating";
+
+// src/telemetry.ts
+import {
+  context,
+  propagation,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+import {
+  logs,
+  SeverityNumber
+} from "@opentelemetry/api-logs";
+
+// src/sanitize.ts
+var DEFAULT_REDACT_KEY_PATTERN = /(password|passwd|token|secret|authorization|jwt|api[_-]?key|cookie|email|credit[_-]?card|ssn)/i;
+var DEFAULT_MAX_STRING_LEN = 2048;
+var DEFAULT_MAX_JSON_LEN = 4096;
+function sanitizeAttrs(input, opts = {}) {
+  if (!input)
+    return {};
+  const redactPattern = opts.redactKeyPattern ?? DEFAULT_REDACT_KEY_PATTERN;
+  const maxStr = opts.maxStringLen ?? DEFAULT_MAX_STRING_LEN;
+  const maxJson = opts.maxJsonLen ?? DEFAULT_MAX_JSON_LEN;
+  const out = {};
+  for (const [key, raw] of Object.entries(input)) {
+    if (redactPattern.test(key))
+      continue;
+    const value = sanitizeValue(raw, redactPattern, maxStr, maxJson);
+    if (value !== undefined)
+      out[key] = value;
+  }
+  return out;
+}
+function sanitizeValue(raw, redactPattern, maxStr, maxJson) {
+  if (raw === null || raw === undefined)
+    return;
+  if (typeof raw === "boolean" || typeof raw === "number")
+    return raw;
+  if (typeof raw === "string") {
+    return raw.length > maxStr ? `${raw.slice(0, maxStr)}…(truncated:${raw.length})` : raw;
+  }
+  try {
+    const filtered = filterRedacted(raw, redactPattern);
+    const json = JSON.stringify(filtered);
+    if (json === undefined)
+      return;
+    return json.length > maxJson ? `${json.slice(0, maxJson)}…(truncated:${json.length})` : json;
+  } catch {
+    return "[unserializable]";
+  }
+}
+function filterRedacted(node, pattern, seen = new WeakSet) {
+  if (node === null || typeof node !== "object")
+    return node;
+  if (seen.has(node))
+    return "[circular]";
+  seen.add(node);
+  if (Array.isArray(node)) {
+    return node.map((v) => filterRedacted(v, pattern, seen));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (pattern.test(k))
+      continue;
+    out[k] = filterRedacted(v, pattern, seen);
+  }
+  return out;
+}
+function redactConnectionString(url) {
+  if (!url)
+    return "";
+  try {
+    const u = new URL(url);
+    if (u.password)
+      u.password = "***";
+    return u.toString();
+  } catch {
+    return "[unparseable]";
+  }
+}
+
+// src/telemetry.ts
+class ArcTelemetry {
+  config;
+  tracer = null;
+  logger = null;
+  meter = null;
+  histograms = new Map;
+  counters = new Map;
+  constructor(config) {
+    const mode = config.mode ?? "development";
+    const enabled = config.enabled ?? mode !== "disabled";
+    const sampleRate = config.sampleRate ?? (config.environment === "server" ? 1 : 0.1);
+    this.config = {
+      ...config,
+      enabled,
+      sampleRate,
+      mode,
+      debug: config.debug ?? false
+    };
+  }
+  attach(opts) {
+    this.tracer = opts.tracer;
+    this.logger = opts.logger ?? null;
+    this.meter = opts.meter ?? null;
+  }
+  get active() {
+    return this.config.enabled && this.tracer !== null;
+  }
+  shouldIncludePayloads() {
+    if (this.config.includePayloads !== undefined)
+      return this.config.includePayloads;
+    return this.config.mode === "development";
+  }
+  async startSpan(name, fn, options = {}) {
+    if (!this.active || !this.tracer) {
+      return fn(trace.getActiveSpan() ?? noopSpan());
+    }
+    const attributes = this.toAttributes(options.attributes, options.unsafeAttrs);
+    return this.tracer.startActiveSpan(name, { kind: options.kind, attributes }, async (span) => {
+      try {
+        const result = await fn(span);
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        this.recordError(span, error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  createSpan(name, options = {}) {
+    if (!this.active || !this.tracer)
+      return noopSpan();
+    const attributes = this.toAttributes(options.attributes, options.unsafeAttrs);
+    return this.tracer.startSpan(name, { kind: options.kind, attributes });
+  }
+  getCurrentSpan() {
+    return trace.getActiveSpan();
+  }
+  withSpan(parent, fn) {
+    return context.with(trace.setSpan(context.active(), parent), fn);
+  }
+  runWithExtractedContext(carrier, fn) {
+    if (!this.active)
+      return fn();
+    const flat = {};
+    if (typeof Headers !== "undefined" && carrier instanceof Headers) {
+      carrier.forEach((value, key) => {
+        flat[key.toLowerCase()] = value;
+      });
+    } else if (carrier) {
+      for (const [k, v] of Object.entries(carrier)) {
+        if (typeof v === "string")
+          flat[k.toLowerCase()] = v;
+      }
+    }
+    const parent = propagation.extract(context.active(), flat);
+    return context.with(parent, fn);
+  }
+  recordError(span, error) {
+    const err = error instanceof Error ? error : new Error(String(error ?? "unknown error"));
+    try {
+      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+      span.recordException(err);
+    } catch {}
+  }
+  addAttributes(attrs, unsafeAttrs = false) {
+    const span = this.getCurrentSpan();
+    if (!span)
+      return;
+    span.setAttributes(this.toAttributes(attrs, unsafeAttrs));
+  }
+  log(level, body, attrs = {}, unsafeAttrs = false) {
+    if (!this.active)
+      return;
+    const logger = this.logger ?? logs.getLogger(this.config.serviceName);
+    const record = {
+      severityNumber: severityFor(level),
+      severityText: level.toUpperCase(),
+      body,
+      attributes: this.toAttributes(attrs, unsafeAttrs)
+    };
+    try {
+      logger.emit(record);
+    } catch {}
+  }
+  incrementCounter(name, value = 1, attrs = {}) {
+    if (!this.active || !this.meter)
+      return;
+    let counter = this.counters.get(name);
+    if (!counter) {
+      counter = this.meter.createCounter(name);
+      this.counters.set(name, counter);
+    }
+    try {
+      counter.add(value, attrs);
+    } catch {}
+  }
+  recordHistogram(name, value, attrs = {}) {
+    if (!this.active || !this.meter)
+      return;
+    let histogram = this.histograms.get(name);
+    if (!histogram) {
+      histogram = this.meter.createHistogram(name, { unit: "ms" });
+      this.histograms.set(name, histogram);
+    }
+    try {
+      histogram.record(value, attrs);
+    } catch {}
+  }
+  measureSince(name, start, attrs = {}) {
+    this.recordHistogram(name, Date.now() - start, attrs);
+  }
+  toAttributes(raw, unsafe) {
+    if (!raw)
+      return {};
+    if (unsafe)
+      return raw;
+    return sanitizeAttrs(raw, this.config.sanitize);
+  }
+}
+function severityFor(level) {
+  switch (level) {
+    case "debug":
+      return SeverityNumber.DEBUG;
+    case "info":
+      return SeverityNumber.INFO;
+    case "warn":
+      return SeverityNumber.WARN;
+    case "error":
+      return SeverityNumber.ERROR;
+    default:
+      return SeverityNumber.INFO;
+  }
+}
+function noopSpan() {
+  return trace.getActiveSpan() ?? trace.wrapSpanContext({
+    traceId: "00000000000000000000000000000000",
+    spanId: "0000000000000000",
+    traceFlags: 0
+  });
+}
+
+// src/init-browser.ts
+function initBrowserTelemetry(config) {
+  const telemetry = new ArcTelemetry({ ...config, environment: "client" });
+  if (!telemetry.config.enabled) {
+    return { telemetry, flush: async () => {} };
+  }
+  const endpoint = config.endpoint ?? "/otel";
+  const resource = new Resource({
+    [ATTR_SERVICE_NAME]: config.serviceName,
+    [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: config.mode ?? "production",
+    "browser.user_agent": navigator.userAgent,
+    "session.id": getOrCreateSessionId()
+  });
+  const processor = new BatchSpanProcessor(new OTLPTraceExporter({ url: `${endpoint}/v1/traces` }), {
+    maxQueueSize: 200,
+    maxExportBatchSize: 20,
+    scheduledDelayMillis: 5000
+  });
+  const provider = new WebTracerProvider({
+    resource,
+    sampler: new ParentBasedSampler({
+      root: new TraceIdRatioBasedSampler(telemetry.config.sampleRate)
+    }),
+    spanProcessors: [processor]
+  });
+  provider.register({
+    propagator: new W3CTraceContextPropagator
+  });
+  propagation2.setGlobalPropagator(new W3CTraceContextPropagator);
+  telemetry.attach({ tracer: provider.getTracer(config.serviceName) });
+  const flushOnExit = () => {
+    processor.forceFlush().catch(() => {});
+  };
+  window.addEventListener("pagehide", flushOnExit);
+  window.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden")
+      flushOnExit();
+  });
+  if (telemetry.config.debug) {
+    console.log("[arc-otel] browser init", {
+      serviceName: config.serviceName,
+      endpoint,
+      sampleRate: telemetry.config.sampleRate
+    });
+  }
+  return {
+    telemetry,
+    flush: () => processor.forceFlush()
+  };
+}
+function getOrCreateSessionId() {
+  try {
+    const KEY = "arc:otel-session-id";
+    let id = sessionStorage.getItem(KEY);
+    if (!id) {
+      id = crypto.randomUUID();
+      sessionStorage.setItem(KEY, id);
+    }
+    return id;
+  } catch {
+    return "no-storage";
+  }
+}
+export {
+  initBrowserTelemetry
+};

package/dist/init-server.d.ts

@@ -0,0 +1,8 @@
+import { ArcTelemetry, type TelemetryConfig } from "./telemetry";
+export interface ServerInitResult {
+    telemetry: ArcTelemetry;
+    /** Flush + shut down all exporters. Call on SIGTERM/SIGINT. Resolves when done. */
+    shutdown: () => Promise<void>;
+}
+export declare function initServerTelemetry(config: TelemetryConfig): ServerInitResult;
+//# sourceMappingURL=init-server.d.ts.map

package/dist/init-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-server.d.ts","sourceRoot":"","sources":["../src/init-server.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAUjE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,mFAAmF;IACnF,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CA2F7E"}

package/dist/init-server.js

@@ -0,0 +1,339 @@
+// src/init-server.ts
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_DEPLOYMENT_ENVIRONMENT_NAME,
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions/incubating";
+
+// src/telemetry.ts
+import {
+  context,
+  propagation,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+import {
+  logs,
+  SeverityNumber
+} from "@opentelemetry/api-logs";
+
+// src/sanitize.ts
+var DEFAULT_REDACT_KEY_PATTERN = /(password|passwd|token|secret|authorization|jwt|api[_-]?key|cookie|email|credit[_-]?card|ssn)/i;
+var DEFAULT_MAX_STRING_LEN = 2048;
+var DEFAULT_MAX_JSON_LEN = 4096;
+function sanitizeAttrs(input, opts = {}) {
+  if (!input)
+    return {};
+  const redactPattern = opts.redactKeyPattern ?? DEFAULT_REDACT_KEY_PATTERN;
+  const maxStr = opts.maxStringLen ?? DEFAULT_MAX_STRING_LEN;
+  const maxJson = opts.maxJsonLen ?? DEFAULT_MAX_JSON_LEN;
+  const out = {};
+  for (const [key, raw] of Object.entries(input)) {
+    if (redactPattern.test(key))
+      continue;
+    const value = sanitizeValue(raw, redactPattern, maxStr, maxJson);
+    if (value !== undefined)
+      out[key] = value;
+  }
+  return out;
+}
+function sanitizeValue(raw, redactPattern, maxStr, maxJson) {
+  if (raw === null || raw === undefined)
+    return;
+  if (typeof raw === "boolean" || typeof raw === "number")
+    return raw;
+  if (typeof raw === "string") {
+    return raw.length > maxStr ? `${raw.slice(0, maxStr)}…(truncated:${raw.length})` : raw;
+  }
+  try {
+    const filtered = filterRedacted(raw, redactPattern);
+    const json = JSON.stringify(filtered);
+    if (json === undefined)
+      return;
+    return json.length > maxJson ? `${json.slice(0, maxJson)}…(truncated:${json.length})` : json;
+  } catch {
+    return "[unserializable]";
+  }
+}
+function filterRedacted(node, pattern, seen = new WeakSet) {
+  if (node === null || typeof node !== "object")
+    return node;
+  if (seen.has(node))
+    return "[circular]";
+  seen.add(node);
+  if (Array.isArray(node)) {
+    return node.map((v) => filterRedacted(v, pattern, seen));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (pattern.test(k))
+      continue;
+    out[k] = filterRedacted(v, pattern, seen);
+  }
+  return out;
+}
+function redactConnectionString(url) {
+  if (!url)
+    return "";
+  try {
+    const u = new URL(url);
+    if (u.password)
+      u.password = "***";
+    return u.toString();
+  } catch {
+    return "[unparseable]";
+  }
+}
+
+// src/telemetry.ts
+class ArcTelemetry {
+  config;
+  tracer = null;
+  logger = null;
+  meter = null;
+  histograms = new Map;
+  counters = new Map;
+  constructor(config) {
+    const mode = config.mode ?? "development";
+    const enabled = config.enabled ?? mode !== "disabled";
+    const sampleRate = config.sampleRate ?? (config.environment === "server" ? 1 : 0.1);
+    this.config = {
+      ...config,
+      enabled,
+      sampleRate,
+      mode,
+      debug: config.debug ?? false
+    };
+  }
+  attach(opts) {
+    this.tracer = opts.tracer;
+    this.logger = opts.logger ?? null;
+    this.meter = opts.meter ?? null;
+  }
+  get active() {
+    return this.config.enabled && this.tracer !== null;
+  }
+  shouldIncludePayloads() {
+    if (this.config.includePayloads !== undefined)
+      return this.config.includePayloads;
+    return this.config.mode === "development";
+  }
+  async startSpan(name, fn, options = {}) {
+    if (!this.active || !this.tracer) {
+      return fn(trace.getActiveSpan() ?? noopSpan());
+    }
+    const attributes = this.toAttributes(options.attributes, options.unsafeAttrs);
+    return this.tracer.startActiveSpan(name, { kind: options.kind, attributes }, async (span) => {
+      try {
+        const result = await fn(span);
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        this.recordError(span, error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  createSpan(name, options = {}) {
+    if (!this.active || !this.tracer)
+      return noopSpan();
+    const attributes = this.toAttributes(options.attributes, options.unsafeAttrs);
+    return this.tracer.startSpan(name, { kind: options.kind, attributes });
+  }
+  getCurrentSpan() {
+    return trace.getActiveSpan();
+  }
+  withSpan(parent, fn) {
+    return context.with(trace.setSpan(context.active(), parent), fn);
+  }
+  runWithExtractedContext(carrier, fn) {
+    if (!this.active)
+      return fn();
+    const flat = {};
+    if (typeof Headers !== "undefined" && carrier instanceof Headers) {
+      carrier.forEach((value, key) => {
+        flat[key.toLowerCase()] = value;
+      });
+    } else if (carrier) {
+      for (const [k, v] of Object.entries(carrier)) {
+        if (typeof v === "string")
+          flat[k.toLowerCase()] = v;
+      }
+    }
+    const parent = propagation.extract(context.active(), flat);
+    return context.with(parent, fn);
+  }
+  recordError(span, error) {
+    const err = error instanceof Error ? error : new Error(String(error ?? "unknown error"));
+    try {
+      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+      span.recordException(err);
+    } catch {}
+  }
+  addAttributes(attrs, unsafeAttrs = false) {
+    const span = this.getCurrentSpan();
+    if (!span)
+      return;
+    span.setAttributes(this.toAttributes(attrs, unsafeAttrs));
+  }
+  log(level, body, attrs = {}, unsafeAttrs = false) {
+    if (!this.active)
+      return;
+    const logger = this.logger ?? logs.getLogger(this.config.serviceName);
+    const record = {
+      severityNumber: severityFor(level),
+      severityText: level.toUpperCase(),
+      body,
+      attributes: this.toAttributes(attrs, unsafeAttrs)
+    };
+    try {
+      logger.emit(record);
+    } catch {}
+  }
+  incrementCounter(name, value = 1, attrs = {}) {
+    if (!this.active || !this.meter)
+      return;
+    let counter = this.counters.get(name);
+    if (!counter) {
+      counter = this.meter.createCounter(name);
+      this.counters.set(name, counter);
+    }
+    try {
+      counter.add(value, attrs);
+    } catch {}
+  }
+  recordHistogram(name, value, attrs = {}) {
+    if (!this.active || !this.meter)
+      return;
+    let histogram = this.histograms.get(name);
+    if (!histogram) {
+      histogram = this.meter.createHistogram(name, { unit: "ms" });
+      this.histograms.set(name, histogram);
+    }
+    try {
+      histogram.record(value, attrs);
+    } catch {}
+  }
+  measureSince(name, start, attrs = {}) {
+    this.recordHistogram(name, Date.now() - start, attrs);
+  }
+  toAttributes(raw, unsafe) {
+    if (!raw)
+      return {};
+    if (unsafe)
+      return raw;
+    return sanitizeAttrs(raw, this.config.sanitize);
+  }
+}
+function severityFor(level) {
+  switch (level) {
+    case "debug":
+      return SeverityNumber.DEBUG;
+    case "info":
+      return SeverityNumber.INFO;
+    case "warn":
+      return SeverityNumber.WARN;
+    case "error":
+      return SeverityNumber.ERROR;
+    default:
+      return SeverityNumber.INFO;
+  }
+}
+function noopSpan() {
+  return trace.getActiveSpan() ?? trace.wrapSpanContext({
+    traceId: "00000000000000000000000000000000",
+    spanId: "0000000000000000",
+    traceFlags: 0
+  });
+}
+
+// src/init-server.ts
+function initServerTelemetry(config) {
+  const telemetry = new ArcTelemetry({ ...config, environment: "server" });
+  if (!telemetry.active && !config.enabled) {
+    return { telemetry, shutdown: async () => {} };
+  }
+  const endpoint = config.endpoint ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318";
+  const resource = new Resource({
+    [ATTR_SERVICE_NAME]: config.serviceName,
+    [ATTR_SERVICE_VERSION]: process.env.ARC_VERSION ?? "unknown",
+    [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: "development"
+  });
+  const tracerProvider = new NodeTracerProvider({
+    resource,
+    sampler: new ParentBasedSampler({
+      root: new TraceIdRatioBasedSampler(telemetry.config.sampleRate)
+    }),
+    spanProcessors: [
+      new BatchSpanProcessor(new OTLPTraceExporter({ url: `${endpoint}/v1/traces` }), {
+        maxQueueSize: 1000,
+        maxExportBatchSize: 50,
+        scheduledDelayMillis: 5000
+      })
+    ]
+  });
+  tracerProvider.register();
+  const loggerProvider = new LoggerProvider({ resource });
+  loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(new OTLPLogExporter({ url: `${endpoint}/v1/logs` }), {
+    maxQueueSize: 1000,
+    maxExportBatchSize: 50,
+    scheduledDelayMillis: 5000
+  }));
+  const meterProvider = new MeterProvider({
+    resource,
+    readers: [
+      new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter({ url: `${endpoint}/v1/metrics` }),
+        exportIntervalMillis: 15000
+      })
+    ]
+  });
+  telemetry.attach({
+    tracer: tracerProvider.getTracer(config.serviceName),
+    logger: loggerProvider.getLogger(config.serviceName),
+    meter: meterProvider.getMeter(config.serviceName)
+  });
+  if (telemetry.config.debug) {
+    console.log("[arc-otel] server init", {
+      serviceName: config.serviceName,
+      endpoint,
+      sampleRate: telemetry.config.sampleRate,
+      mode: telemetry.config.mode
+    });
+  }
+  const shutdown = async () => {
+    try {
+      await Promise.all([
+        tracerProvider.shutdown(),
+        loggerProvider.shutdown(),
+        meterProvider.shutdown()
+      ]);
+    } catch (err) {
+      console.error("[arc-otel] shutdown error", err);
+    }
+  };
+  return { telemetry, shutdown };
+}
+export {
+  initServerTelemetry
+};