risicare 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -49,9 +49,11 @@ __export(src_exports, {
   getCurrentSpan: () => getCurrentSpan,
   getCurrentSpanId: () => getCurrentSpanId,
   getCurrentTraceId: () => getCurrentTraceId,
+  getMetrics: () => getMetrics,
   getSpanById: () => getSpanById,
+  getTraceContent: () => getTraceContent,
   getTraceContext: () => getTraceContext,
-  getTracer: () => getTracer,
+  getTracer: () => getTracer2,
   init: () => init,
   injectTraceContext: () => injectTraceContext,
   isEnabled: () => isEnabled,
@@ -85,6 +87,7 @@ function resolveConfig(config) {
   const traceContent = config?.traceContent ?? parseBool(env.RISICARE_TRACE_CONTENT, true);
   const sampleRate = config?.sampleRate ?? parseFloat(env.RISICARE_SAMPLE_RATE ?? "1.0");
   const debug2 = config?.debug ?? parseBool(env.RISICARE_DEBUG, false);
+  const compress = config?.compress ?? parseBool(env.RISICARE_COMPRESS, false);
   const batchSize = config?.batchSize ?? 100;
   const batchTimeoutMs = config?.batchTimeoutMs ?? 1e3;
   const maxQueueSize = config?.maxQueueSize ?? 1e4;
@@ -110,6 +113,7 @@ function resolveConfig(config) {
     batchTimeoutMs,
     maxQueueSize,
     debug: debug2,
+    compress,
     metadata: config?.metadata ?? {}
   };
 }
@@ -130,7 +134,7 @@ function generateSpanId() {
   return (0, import_node_crypto.randomBytes)(8).toString("hex");
 }
 function generateAgentId(prefix) {
-  const suffix = (0, import_node_crypto.randomBytes)(6).toString("hex");
+  const suffix = (0, import_node_crypto.randomBytes)(8).toString("hex");
   return prefix ? `${prefix}-${suffix}` : suffix;
 }
 function validateTraceId(id) {
@@ -447,16 +451,58 @@ function shouldSample(traceId, sampleRate) {
   return hash / 4294967295 < sampleRate;
 }
 
-// src/context/storage.ts
+// src/globals.ts
 var import_node_async_hooks = require("async_hooks");
-var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+var G = globalThis;
+var PREFIX = "__risicare_";
+function getClient() {
+  return G[PREFIX + "client"];
+}
+function setClient(client) {
+  G[PREFIX + "client"] = client;
+}
+function getTracer() {
+  return G[PREFIX + "tracer"];
+}
+function setTracer(tracer) {
+  G[PREFIX + "tracer"] = tracer;
+}
+function getContextStorage() {
+  if (!G[PREFIX + "ctx"]) {
+    G[PREFIX + "ctx"] = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  return G[PREFIX + "ctx"];
+}
+function getRegistry() {
+  if (!G[PREFIX + "registry"]) {
+    G[PREFIX + "registry"] = /* @__PURE__ */ new Map();
+  }
+  return G[PREFIX + "registry"];
+}
+function getOpCount() {
+  return G[PREFIX + "opcount"] ?? 0;
+}
+function setOpCount(n) {
+  G[PREFIX + "opcount"] = n;
+}
+function getDebug() {
+  return G[PREFIX + "debug"] ?? false;
+}
+function setDebugFlag(enabled) {
+  G[PREFIX + "debug"] = enabled;
+}
+
+// src/context/storage.ts
+function storage() {
+  return getContextStorage();
+}
 function getContext() {
-  return contextStorage.getStore() ?? {};
+  return storage().getStore() ?? {};
 }
 function runWithContext(overrides, fn) {
   const parent = getContext();
   const merged = { ...parent, ...overrides };
-  return contextStorage.run(merged, fn);
+  return storage().run(merged, fn);
 }
 function getCurrentSession() {
   return getContext().session;
@@ -497,10 +543,12 @@ var Tracer = class {
   _onSpanEnd;
   _sampleRate;
   _enabled;
+  _traceContent;
   constructor(config) {
     this._onSpanEnd = config.onSpanEnd;
     this._sampleRate = config.sampleRate ?? 1;
     this._enabled = config.enabled ?? true;
+    this._traceContent = config.traceContent ?? true;
   }
   get enabled() {
     return this._enabled;
@@ -508,6 +556,9 @@ var Tracer = class {
   set enabled(value) {
     this._enabled = value;
   }
+  get traceContent() {
+    return this._traceContent;
+  }
   /**
    * Start a span, run the callback within its context, and auto-end on completion.
    *
@@ -613,12 +664,11 @@ var Tracer = class {
 };
 
 // src/utils/log.ts
-var _debug = false;
 function setDebug(enabled) {
-  _debug = enabled;
+  setDebugFlag(enabled);
 }
 function debug(msg) {
-  if (_debug) {
+  if (getDebug()) {
     process.stderr.write(`[risicare] ${msg}
 `);
   }
@@ -629,7 +679,7 @@ function warn(msg) {
 }
 
 // src/exporters/batch.ts
-var BatchSpanProcessor = class {
+var BatchSpanProcessor = class _BatchSpanProcessor {
   _exporters;
   _batchSize;
   _batchTimeoutMs;
@@ -639,6 +689,10 @@ var BatchSpanProcessor = class {
   _timer = null;
   _started = false;
   _flushing = false;
+  _beforeExitHandler = null;
+  // Retry tracking for failed batches (Audit #5)
+  _retryCounts = /* @__PURE__ */ new Map();
+  static MAX_RETRIES = 3;
   // Metrics
   droppedSpans = 0;
   exportedSpans = 0;
@@ -657,9 +711,10 @@ var BatchSpanProcessor = class {
       void this._exportBatch();
     }, this._batchTimeoutMs);
     this._timer.unref();
-    process.on("beforeExit", () => {
+    this._beforeExitHandler = () => {
       void this.shutdown();
-    });
+    };
+    process.once("beforeExit", this._beforeExitHandler);
   }
   async shutdown(timeoutMs = 5e3) {
     if (!this._started) return;
@@ -668,6 +723,10 @@ var BatchSpanProcessor = class {
       clearInterval(this._timer);
       this._timer = null;
     }
+    if (this._beforeExitHandler) {
+      process.removeListener("beforeExit", this._beforeExitHandler);
+      this._beforeExitHandler = null;
+    }
     const flushPromise = this._exportBatch();
     const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
     await Promise.race([flushPromise, timeoutPromise]);
@@ -678,6 +737,7 @@ var BatchSpanProcessor = class {
         debug(`Error shutting down ${exporter.name}: ${e}`);
       }
     }
+    this._retryCounts.clear();
     debug(
       `BatchSpanProcessor shutdown. Exported: ${this.exportedSpans}, Dropped: ${this.droppedSpans}, Failed: ${this.failedExports}`
     );
@@ -734,6 +794,9 @@ var BatchSpanProcessor = class {
             if (!batchExported) {
               this.exportedSpans += batch.length;
               batchExported = true;
+              for (const span of batch) {
+                this._retryCounts.delete(span.spanId);
+              }
             }
           } else {
             this.failedExports++;
@@ -743,6 +806,22 @@ var BatchSpanProcessor = class {
           debug(`Export to ${exporter.name} failed: ${e}`);
         }
       }
+      if (!batchExported) {
+        const retryable = batch.filter((span) => {
+          const count = (this._retryCounts.get(span.spanId) ?? 0) + 1;
+          if (count > _BatchSpanProcessor.MAX_RETRIES) {
+            this._retryCounts.delete(span.spanId);
+            this.droppedSpans++;
+            return false;
+          }
+          this._retryCounts.set(span.spanId, count);
+          return true;
+        });
+        if (retryable.length > 0) {
+          this._queue.unshift(...retryable);
+          debug(`Re-queued ${retryable.length} spans for retry (${batch.length - retryable.length} dropped after max retries)`);
+        }
+      }
     } finally {
       this._flushing = false;
     }
@@ -750,6 +829,7 @@ var BatchSpanProcessor = class {
 };
 
 // src/exporters/http.ts
+var SDK_VERSION = "0.1.1";
 var HttpExporter = class {
   name = "http";
   _endpoint;
@@ -776,23 +856,26 @@ var HttpExporter = class {
   async export(spans) {
     if (spans.length === 0) return "success" /* SUCCESS */;
     const now = Date.now();
+    let isHalfOpen = false;
     if (this._consecutiveFailures >= this._circuitBreakerThreshold) {
       if (now < this._circuitOpenUntil) {
         return "failure" /* FAILURE */;
       }
+      isHalfOpen = true;
     }
     const body = {
       spans: spans.map((s) => s.toPayload())
     };
     if (this._projectId) body.projectId = this._projectId;
     if (this._environment) body.environment = this._environment;
-    for (let attempt = 0; attempt < this._maxRetries; attempt++) {
+    const maxAttempts = isHalfOpen ? 1 : this._maxRetries;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const result = await this._sendRequest(body);
       if (result === "success" /* SUCCESS */) {
         this._consecutiveFailures = 0;
         return result;
       }
-      if (attempt < this._maxRetries - 1) {
+      if (attempt < maxAttempts - 1) {
         await sleep(100 * Math.pow(2, attempt));
       }
     }
@@ -808,7 +891,8 @@ var HttpExporter = class {
   async _sendRequest(body) {
     const url = `${this._endpoint}/v1/spans`;
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "User-Agent": `risicare-js/${SDK_VERSION} node/${process.version}`
     };
     if (this._apiKey) {
       headers["Authorization"] = `Bearer ${this._apiKey}`;
@@ -819,7 +903,8 @@ var HttpExporter = class {
         const { gzipSync } = await import("zlib");
         payload = gzipSync(Buffer.from(payload));
         headers["Content-Encoding"] = "gzip";
-      } catch {
+      } catch (e) {
+        debug(`Gzip compression failed, sending uncompressed: ${e}`);
       }
     }
     try {
@@ -869,15 +954,17 @@ var ConsoleExporter = class {
 };
 
 // src/client.ts
-var _client;
-var _tracer;
 var RisicareClient = class {
   config;
   processor;
   tracer;
-  _shutdownCalled = false;
+  _shutdownPromise;
+  _shutdownHandlers = [];
   constructor(config) {
     this.config = resolveConfig(config);
+    if (this.config.apiKey && !this.config.apiKey.startsWith("rsk-")) {
+      debug('Warning: API key should start with "rsk-". Got: ' + this.config.apiKey.slice(0, 4) + "...");
+    }
     let exporter;
     if (this.config.debug && !this.config.apiKey) {
       exporter = new ConsoleExporter();
@@ -886,7 +973,8 @@ var RisicareClient = class {
         endpoint: this.config.endpoint,
         apiKey: this.config.apiKey,
         projectId: this.config.projectId || void 0,
-        environment: this.config.environment || void 0
+        environment: this.config.environment || void 0,
+        compress: this.config.compress
       });
     } else {
       exporter = new ConsoleExporter();
@@ -901,7 +989,8 @@ var RisicareClient = class {
     this.tracer = new Tracer({
       onSpanEnd: (span) => this.processor.onSpanEnd(span),
       sampleRate: this.config.sampleRate,
-      enabled: this.config.enabled
+      enabled: this.config.enabled,
+      traceContent: this.config.traceContent
     });
     this.processor.start();
     this._registerShutdownHooks();
@@ -914,10 +1003,18 @@ var RisicareClient = class {
   set enabled(value) {
     this.tracer.enabled = value;
   }
+  // Audit #6: Promise-based shutdown dedup (fixes TOCTOU race condition)
   async shutdown() {
-    if (this._shutdownCalled) return;
-    this._shutdownCalled = true;
+    if (this._shutdownPromise) return this._shutdownPromise;
+    this._shutdownPromise = this._doShutdown();
+    return this._shutdownPromise;
+  }
+  async _doShutdown() {
     debug("Shutting down...");
+    for (const { signal, handler } of this._shutdownHandlers) {
+      process.removeListener(signal, handler);
+    }
+    this._shutdownHandlers = [];
     await this.processor.shutdown();
   }
   async flush() {
@@ -925,43 +1022,68 @@ var RisicareClient = class {
   }
   _registerShutdownHooks() {
     const onShutdown = () => {
+      const timeout = setTimeout(() => process.exit(1), 5e3);
+      timeout.unref();
       this.shutdown().catch(() => {
-      });
+      }).finally(() => clearTimeout(timeout));
     };
-    process.once("beforeExit", onShutdown);
-    process.once("SIGTERM", onShutdown);
-    process.once("SIGINT", onShutdown);
+    const signals = ["beforeExit", "SIGTERM", "SIGINT"];
+    for (const signal of signals) {
+      process.once(signal, onShutdown);
+      this._shutdownHandlers.push({ signal, handler: onShutdown });
+    }
   }
 };
 function init(config) {
-  if (_client) {
+  if (getClient()) {
     debug("Already initialized. Call shutdown() first to re-initialize.");
     return;
   }
-  _client = new RisicareClient(config);
-  _tracer = _client.tracer;
+  const client = new RisicareClient(config);
+  setClient(client);
+  setTracer(client.tracer);
 }
 async function shutdown() {
-  if (!_client) return;
-  await _client.shutdown();
-  _client = void 0;
-  _tracer = void 0;
+  const client = getClient();
+  if (!client) return;
+  await client.shutdown();
+  setClient(void 0);
+  setTracer(void 0);
 }
 async function flush() {
-  if (!_client) return;
-  await _client.flush();
+  const client = getClient();
+  if (!client) return;
+  await client.flush();
 }
 function enable() {
-  if (_client) _client.enabled = true;
+  const client = getClient();
+  if (client) client.enabled = true;
 }
 function disable() {
-  if (_client) _client.enabled = false;
+  const client = getClient();
+  if (client) client.enabled = false;
 }
 function isEnabled() {
-  return _client?.enabled ?? false;
+  const client = getClient();
+  return client?.enabled ?? false;
 }
-function getTracer() {
-  return _tracer;
+function getTracer2() {
+  return getTracer();
+}
+function getTraceContent() {
+  const tracer = getTracer();
+  return tracer?.traceContent ?? true;
+}
+function getMetrics() {
+  const client = getClient();
+  return client?.processor.getMetrics() ?? {
+    exportedSpans: 0,
+    droppedSpans: 0,
+    failedExports: 0,
+    queueSize: 0,
+    queueCapacity: 0,
+    queueUtilization: 0
+  };
 }
 
 // src/context/agent.ts
@@ -985,7 +1107,7 @@ function withAgent(options, fn) {
 function agent(options, fn) {
   const spanName = `agent:${options.name ?? "agent"}`;
   return (...args) => {
-    const tracer = getTracer();
+    const tracer = getTracer2();
     if (!tracer) {
       return fn(...args);
     }
@@ -1027,7 +1149,7 @@ function withPhase(phase, fn) {
 // src/decorators/phase.ts
 function phaseWrapper(phase, fn) {
   return (...args) => {
-    const tracer = getTracer();
+    const tracer = getTracer2();
     if (!tracer) {
       return fn(...args);
     }
@@ -1061,7 +1183,7 @@ function namespacedMetadata(metadata) {
 function traceMessage(options, fn) {
   const msgType = options.type ?? "request" /* REQUEST */;
   return (...args) => {
-    const tracer = getTracer();
+    const tracer = getTracer2();
     if (!tracer) return fn(...args);
     return tracer.startSpan(
       {
@@ -1080,7 +1202,7 @@ function traceMessage(options, fn) {
 }
 function traceDelegate(options, fn) {
   return (...args) => {
-    const tracer = getTracer();
+    const tracer = getTracer2();
     if (!tracer) return fn(...args);
     return tracer.startSpan(
       {
@@ -1099,7 +1221,7 @@ function traceDelegate(options, fn) {
 }
 function traceCoordinate(options, fn) {
   return (...args) => {
-    const tracer = getTracer();
+    const tracer = getTracer2();
     if (!tracer) return fn(...args);
     return tracer.startSpan(
       {
@@ -1190,36 +1312,37 @@ function extractTraceContext(headers) {
 var DEFAULT_TTL_MS = 6e4;
 var MAX_ENTRIES = 1e4;
 var CLEANUP_INTERVAL = 100;
-var entries = /* @__PURE__ */ new Map();
-var operationCount = 0;
+function entries() {
+  return getRegistry();
+}
 function registerSpan(span, ttlMs = DEFAULT_TTL_MS) {
-  entries.set(span.spanId, {
+  entries().set(span.spanId, {
     span,
     registeredAt: Date.now(),
     ttlMs
   });
-  operationCount++;
+  setOpCount(getOpCount() + 1);
   maybeCleanup();
 }
 function getSpanById(spanId) {
-  const entry = entries.get(spanId);
+  const entry = entries().get(spanId);
   if (!entry) return void 0;
   if (Date.now() - entry.registeredAt > entry.ttlMs) {
-    entries.delete(spanId);
+    entries().delete(spanId);
     return void 0;
   }
   return entry.span;
 }
 function unregisterSpan(spanId) {
-  entries.delete(spanId);
+  entries().delete(spanId);
 }
 function maybeCleanup() {
-  if (operationCount % CLEANUP_INTERVAL !== 0) return;
-  if (entries.size <= MAX_ENTRIES) return;
+  if (getOpCount() % CLEANUP_INTERVAL !== 0) return;
+  if (entries().size <= MAX_ENTRIES) return;
   const now = Date.now();
-  for (const [id, entry] of entries) {
+  for (const [id, entry] of entries()) {
     if (now - entry.registeredAt > entry.ttlMs) {
-      entries.delete(id);
+      entries().delete(id);
     }
   }
 }
@@ -1244,7 +1367,9 @@ function maybeCleanup() {
   getCurrentSpan,
   getCurrentSpanId,
   getCurrentTraceId,
+  getMetrics,
   getSpanById,
+  getTraceContent,
   getTraceContext,
   getTracer,
   init,