@sentienguard/apm 1.0.23-debug.1 → 1.0.23

package/README.md

@@ -1,141 +1,177 @@
-# @sentienguard/apm
-
-Minimal, production-safe APM SDK for Node.js applications. Zero-config setup with automatic instrumentation.
-
-## Installation
-
-```bash
-npm install @sentienguard/apm
-```
-
-## Quick Start
-
-```js
-// If using dotenv, import it first
-import 'dotenv/config';
-
-// Then import the SDK (before other app modules for best instrumentation coverage)
-import '@sentienguard/apm';
-
-// Your app code
-import express from 'express';
-const app = express();
-// ...
-```
-
-Set environment variables:
-
-```bash
-SENTIENGUARD_APM_KEY=your-app-key
-SENTIENGUARD_SERVICE=my-api
-```
-
-That's it. The SDK automatically instruments your application and sends metrics to SentienGuard.
-
-## Configuration
-
-All configuration is via environment variables:
-
-| Variable | Required | Default | Description |
-|----------|----------|---------|-------------|
-| `SENTIENGUARD_APM_KEY` | Yes | - | Your application's APM key |
-| `SENTIENGUARD_SERVICE` | Yes | - | Service name (e.g., `orders-api`) |
-| `SENTIENGUARD_ENV` | No | `production` | Environment (`production`, `staging`, `development`) |
-| `SENTIENGUARD_ENDPOINT` | No | `https://sentienguard-dev.the-algo.com/api/v1` | SentienGuard backend URL |
-| `SENTIENGUARD_FLUSH_INTERVAL` | No | `10` | Metrics flush interval in seconds |
-
-> **Note:** If `SENTIENGUARD_APM_KEY` or `SENTIENGUARD_SERVICE` is missing, the SDK disables itself silently without affecting your application.
-
-## What Gets Tracked
-
-- **HTTP Requests** - Incoming requests with method, route, status, and latency
-- **Dependencies** - Outgoing HTTP/HTTPS calls to external services
-- **Errors** - Uncaught exceptions and unhandled rejections
-
-## Framework Integration
-
-### Express
-
-For better route extraction, add the middleware:
-
-```js
-import 'dotenv/config'; // if using dotenv
-import '@sentienguard/apm';
-import { expressMiddleware, expressErrorMiddleware } from '@sentienguard/apm';
-import express from 'express';
-
-const app = express();
-
-// Add early in middleware chain
-app.use(expressMiddleware());
-
-// Your routes
-app.get('/users/:id', (req, res) => { ... });
-
-// Add error middleware last
-app.use(expressErrorMiddleware());
-```
-
-### Fastify
-
-```js
-import 'dotenv/config'; // if using dotenv
-import '@sentienguard/apm';
-import { fastifyPlugin, fastifyErrorHandler } from '@sentienguard/apm';
-import Fastify from 'fastify';
-
-const app = Fastify();
-
-// Register plugin
-app.register(fastifyPlugin);
-
-// Add error handler
-app.setErrorHandler(fastifyErrorHandler);
-```
-
-## API Reference
-
-### Functions
-
-```js
-import {
-  shutdown,      // Graceful shutdown (flushes pending metrics)
-  getStatus,     // Get SDK status and stats
-  flush,         // Force flush metrics now
-  isEnabled      // Check if SDK is enabled
-} from '@sentienguard/apm';
-```
-
-### Graceful Shutdown
-
-The SDK automatically handles `SIGTERM` and `SIGINT` signals. For manual shutdown:
-
-```js
-import { shutdown } from '@sentienguard/apm';
-
-process.on('exit', async () => {
-  await shutdown();
-});
-```
-
-### Check Status
-
-```js
-import { getStatus } from '@sentienguard/apm';
-
-console.log(getStatus());
-// {
-//   enabled: true,
-//   initialized: true,
-//   config: { service: 'my-api', environment: 'production', flushInterval: 10 },
-//   stats: { requests: 150, dependencies: 45, errors: 2 }
-// }
-```
-
-## Requirements
-
-- Node.js >= 16.0.0
-
-## License
-
-MIT
+# @sentienguard/apm
+
+Minimal, production-safe APM SDK for Node.js applications. Zero-config setup with automatic instrumentation.
+
+## Installation
+
+```bash
+npm install @sentienguard/apm
+```
+
+## Quick Start
+
+```js
+// If using dotenv, import it first
+import 'dotenv/config';
+
+// Then import the SDK (before other app modules for best instrumentation coverage)
+import '@sentienguard/apm';
+
+// Your app code
+import express from 'express';
+const app = express();
+// ...
+```
+
+Set environment variables:
+
+```bash
+SENTIENGUARD_APM_KEY=your-app-key
+SENTIENGUARD_SERVICE=my-api
+```
+
+That's it. The SDK automatically instruments your application and sends metrics to SentienGuard.
+
+## Configuration
+
+All configuration is via environment variables:
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `SENTIENGUARD_APM_KEY` | Yes | - | Your application's APM key |
+| `SENTIENGUARD_SERVICE` | Yes | - | Service name (e.g., `orders-api`) |
+| `SENTIENGUARD_ENV` | No | `production` | Environment (`production`, `staging`, `development`) |
+| `SENTIENGUARD_ENDPOINT` | No | `https://sentienguard-dev.the-algo.com/api/v1` | SentienGuard backend URL |
+| `SENTIENGUARD_FLUSH_INTERVAL` | No | `10` | Metrics flush interval in seconds |
+
+> **Note:** If `SENTIENGUARD_APM_KEY` or `SENTIENGUARD_SERVICE` is missing, the SDK disables itself silently without affecting your application.
+
+## What Gets Tracked
+
+- **HTTP Requests** - Incoming requests with method, route, status, and latency
+- **Dependencies** - Outgoing HTTP/HTTPS calls to external services
+- **Errors** - Uncaught exceptions and unhandled rejections
+
+## Framework Integration
+
+### Express
+
+For better route extraction, add the middleware:
+
+```js
+import 'dotenv/config'; // if using dotenv
+import '@sentienguard/apm';
+import { expressMiddleware, expressErrorMiddleware } from '@sentienguard/apm';
+import express from 'express';
+
+const app = express();
+
+// Add early in middleware chain
+app.use(expressMiddleware());
+
+// Your routes
+app.get('/users/:id', (req, res) => { ... });
+
+// Add error middleware last
+app.use(expressErrorMiddleware());
+```
+
+### Fastify
+
+```js
+import 'dotenv/config'; // if using dotenv
+import '@sentienguard/apm';
+import { fastifyPlugin, fastifyErrorHandler } from '@sentienguard/apm';
+import Fastify from 'fastify';
+
+const app = Fastify();
+
+// Register plugin
+app.register(fastifyPlugin);
+
+// Add error handler
+app.setErrorHandler(fastifyErrorHandler);
+```
+
+## API Reference
+
+### Functions
+
+```js
+import {
+  shutdown,      // Graceful shutdown (flushes pending metrics)
+  getStatus,     // Get SDK status and stats
+  flush,         // Force flush metrics now
+  isEnabled      // Check if SDK is enabled
+} from '@sentienguard/apm';
+```
+
+### Graceful Shutdown
+
+The SDK automatically handles `SIGTERM` and `SIGINT` signals. For manual shutdown:
+
+```js
+import { shutdown } from '@sentienguard/apm';
+
+process.on('exit', async () => {
+  await shutdown();
+});
+```
+
+### Check Status
+
+```js
+import { getStatus } from '@sentienguard/apm';
+
+console.log(getStatus());
+// {
+//   enabled: true,
+//   initialized: true,
+//   config: { service: 'my-api', environment: 'production', flushInterval: 10 },
+//   stats: { requests: 150, dependencies: 45, errors: 2 }
+// }
+```
+
+## Browser / Frontend Monitoring (RUM)
+
+For React, Vue, or other browser apps, bundlers automatically use the browser build.
+Call `init()` explicitly in your app entry (client-side only):
+
+```js
+import SentienGuard from '@sentienguard/apm';
+
+SentienGuard.init({
+  apiKey: 'your-apm-key',
+  service: 'my-frontend',
+  endpoint: 'https://your-backend.com/api/v1/apm/ingest',
+  environment: 'production'
+});
+```
+
+### What Gets Tracked (Browser)
+
+- **Outgoing fetch/XHR** — API calls from the browser with latency and errors
+- **Core Web Vitals** — LCP, FID, INP, CLS
+- **Page load timing** — TTFB, DOM ready, full load
+- **JS errors** — Unhandled exceptions and promise rejections
+- **SPA routes** — Client-side navigation via History API
+
+### Browser Configuration
+
+| Option | Required | Default | Description |
+|--------|----------|---------|-------------|
+| `apiKey` | Yes | - | APM application key |
+| `service` | Yes | - | Frontend service name |
+| `endpoint` | No | SentienGuard dev ingest URL | Full ingest URL |
+| `environment` | No | `production` | Environment name |
+| `flushInterval` | No | `10` | Flush interval in seconds |
+| `debug` | No | `false` | Enable SDK debug logging |
+
+## Requirements
+
+- Node.js >= 16.0.0 (server SDK)
+- Modern browser with PerformanceObserver support (browser SDK)
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentienguard/apm",
-  "version": "1.0.23-debug.1",
+  "version": "1.0.23",
   "description": "SentienGuard APM SDK - Minimal, production-safe application performance monitoring",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/browser/aggregator.js

@@ -139,6 +139,29 @@ export class BrowserMetricsAggregator {
       });
     }
 
+    const webVitals = Object.keys(this.webVitals).length > 0
+      ? { ...this.webVitals }
+      : undefined;
+
+    const jsErrors = this.jsErrors > 0 ? this.jsErrors : undefined;
+
+    const routeChanges = this.routeChanges.length > 0
+      ? this.routeChanges.map(({ from, to, timestamp }) => ({ from, to, timestamp }))
+      : undefined;
+
+    const pageLoads = this.pageLoads.length > 0
+      ? this.pageLoads.map((timing) => ({
+        dns: Math.round(timing.dns || 0),
+        tcp: Math.round(timing.tcp || 0),
+        tls: Math.round(timing.tls || 0),
+        ttfb: Math.round(timing.ttfb || 0),
+        download: Math.round(timing.download || 0),
+        domInteractive: Math.round(timing.domInteractive || 0),
+        domContentLoaded: Math.round(timing.domContentLoaded || 0),
+        load: Math.round(timing.load || 0)
+      }))
+      : undefined;
+
     const payload = {
       interval: `${config.flushInterval}s`,
       service: config.service,
@@ -147,6 +170,11 @@ export class BrowserMetricsAggregator {
       dependencies: []
     };
 
+    if (webVitals) payload.webVitals = webVitals;
+    if (jsErrors) payload.jsErrors = jsErrors;
+    if (routeChanges) payload.routeChanges = routeChanges;
+    if (pageLoads) payload.pageLoads = pageLoads;
+
     this.reset();
     return payload;
   }

package/src/browser/transport.js

@@ -87,7 +87,16 @@ export async function flush() {
   if (!aggregator.hasData()) return;
 
   const payload = aggregator.flush();
-  debug(`Flushing ${payload.requests.length} request metrics`);
+  const frontendExtras = [
+    payload.webVitals ? 'vitals' : null,
+    payload.jsErrors ? 'errors' : null,
+    payload.routeChanges?.length ? 'routes' : null,
+    payload.pageLoads?.length ? 'pageLoads' : null
+  ].filter(Boolean);
+  debug(
+    `Flushing ${payload.requests.length} request metrics` +
+    (frontendExtras.length ? ` + ${frontendExtras.join(', ')}` : '')
+  );
 
   try {
     const startTime = performance.now();

package/src/bunManualSpans.js

@@ -0,0 +1,20 @@
+/**
+ * Bun + OpenTelemetry: @opentelemetry/instrumentation-http does not hook Bun's HTTP stack,
+ * so NodeSDK starts but produces no spans. Emit spans via the OTel API so they still reach
+ * BatchSpanProcessor → SentienGuardTraceSpanExporter (same as Node).
+ */
+
+import { context, trace, SpanKind, SpanStatusCode } from '@opentelemetry/api';
+import { isTracingActive } from './tracing.js';
+
+const TRACER_NAME = '@sentienguard/apm';
+
+export function shouldEmitBunManualSpans() {
+  return typeof globalThis.Bun !== 'undefined' && isTracingActive();
+}
+
+export function getBunTracer() {
+  return trace.getTracer(TRACER_NAME);
+}
+
+export { context, trace, SpanKind, SpanStatusCode };

package/src/dependencies.js

@@ -11,9 +11,10 @@
 
 import http from 'http';
 import https from 'https';
-import { context, propagation } from '@opentelemetry/api';
+import { context, propagation, trace, SpanKind, SpanStatusCode } from '@opentelemetry/api';
 import { getAggregator } from './aggregator.js';
 import { debug, getConfig } from './config.js';
+import { shouldEmitBunManualSpans, getBunTracer } from './bunManualSpans.js';
 
 let isInstrumented = false;
 let originalHttpRequest = null;
@@ -178,6 +179,22 @@ function shouldExcludeUrl(u) {
   return shouldExclude(u.hostname, u);
 }
 
+/** Full URL string for outgoing http.request options (for trace attributes). */
+function safeOutgoingUrl(options) {
+  try {
+    if (typeof options === 'string') return options;
+    if (!options || typeof options !== 'object') return '';
+    const protocol = options.protocol || 'http:';
+    const hostRaw = options.hostname || options.host || '';
+    const host = String(hostRaw).trim().split(':')[0];
+    const path = options.path || options.pathname || '/';
+    if (!host) return '';
+    return `${protocol}//${host}${path}`;
+  } catch {
+    return '';
+  }
+}
+
 function injectTraceHeaders(init) {
   const headers = new Headers((init && init.headers) || {});
   try {
@@ -215,6 +232,45 @@ export function instrumentFetch() {
     const peerLabel = resolveOutgoingPeerLabel(hostname, u ? u.toString() : '');
     const depType = getDependencyType(hostname, u?.pathname || '/');
 
+    if (shouldEmitBunManualSpans()) {
+      const tracer = getBunTracer();
+      const method = (init && init.method && String(init.method).toUpperCase()) || 'GET';
+      const span = tracer.startSpan(`HTTP ${method}`, { kind: SpanKind.CLIENT });
+      span.setAttribute('http.method', method);
+      if (hostname) span.setAttribute('net.peer.name', hostname);
+      if (u?.href) span.setAttribute('http.url', u.href);
+      const ctx = trace.setSpan(context.active(), span);
+      return context.with(ctx, async () => {
+        try {
+          const res = await originalFetch.call(this, input, injectTraceHeaders(init));
+          const endTime = process.hrtime.bigint();
+          const latencyMs = Number(endTime - startTime) / 1e6;
+          const isError = (res?.status || 0) >= 400;
+          span.setAttribute('http.status_code', res?.status || 0);
+          span.setStatus(
+            isError ? { code: SpanStatusCode.ERROR } : { code: SpanStatusCode.OK }
+          );
+          getAggregator().recordDependency(peerLabel, depType, latencyMs, isError);
+          debug(`Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) ${res?.status}`);
+          return res;
+        } catch (err) {
+          const endTime = process.hrtime.bigint();
+          const latencyMs = Number(endTime - startTime) / 1e6;
+          span.recordException(err);
+          span.setStatus({ code: SpanStatusCode.ERROR });
+          getAggregator().recordDependency(peerLabel, depType, latencyMs, true);
+          debug(`Service call: ${caller} -> ${peerLabel} ${latencyMs.toFixed(2)}ms (${depType}) error`);
+          throw err;
+        } finally {
+          try {
+            span.end();
+          } catch {
+            /* ignore */
+          }
+        }
+      });
+    }
+
     try {
       const res = await originalFetch.call(this, input, injectTraceHeaders(init));
       const endTime = process.hrtime.bigint();
@@ -270,11 +326,52 @@ function wrapRequest(original, protocol) {
     const depType = getDependencyType(hostname, path);
     const caller = getConfig().service || 'unknown';
 
-    // Call original
-    const req = original.apply(this, arguments);
+    let clientSpan = null;
+    let clientSpanEnded = false;
+    const finishClientSpan = (statusCode, networkError) => {
+      if (!clientSpan || clientSpanEnded) return;
+      clientSpanEnded = true;
+      try {
+        if (statusCode > 0) {
+          clientSpan.setAttribute('http.status_code', statusCode);
+        }
+        clientSpan.setStatus(
+          networkError || statusCode >= 400
+            ? { code: SpanStatusCode.ERROR }
+            : { code: SpanStatusCode.OK }
+        );
+        clientSpan.end();
+      } catch {
+        /* ignore */
+      }
+    };
+
+    if (shouldEmitBunManualSpans()) {
+      try {
+        const tracer = getBunTracer();
+        const method =
+          typeof options === 'string'
+            ? 'GET'
+            : String(options?.method || 'GET').toUpperCase();
+        clientSpan = tracer.startSpan(`HTTP ${method}`, { kind: SpanKind.CLIENT });
+        clientSpan.setAttribute('http.method', method);
+        if (hostname) clientSpan.setAttribute('net.peer.name', hostname);
+        const urlStr = safeOutgoingUrl(options);
+        if (urlStr) clientSpan.setAttribute('http.url', urlStr);
+      } catch {
+        clientSpan = null;
+      }
+    }
+
+    const req = clientSpan
+      ? context.with(trace.setSpan(context.active(), clientSpan), () =>
+          original.apply(this, arguments)
+        )
+      : original.apply(this, arguments);
 
     // Track response
     req.on('response', (res) => {
+      finishClientSpan(res.statusCode || 0, false);
       const endTime = process.hrtime.bigint();
       const latencyMs = Number(endTime - startTime) / 1e6;
       const isError = res.statusCode >= 400;
@@ -289,6 +386,7 @@ function wrapRequest(original, protocol) {
 
     // Track errors
     req.on('error', () => {
+      finishClientSpan(0, true);
       const endTime = process.hrtime.bigint();
       const latencyMs = Number(endTime - startTime) / 1e6;
 

package/src/instrumentation.js

@@ -16,6 +16,14 @@ import { extractRoute } from './normalizer.js';
 import { getAggregator } from './aggregator.js';
 import { debug } from './config.js';
 import { isTracingActive } from './tracing.js';
+import {
+  context,
+  trace,
+  SpanKind,
+  SpanStatusCode,
+  shouldEmitBunManualSpans,
+  getBunTracer
+} from './bunManualSpans.js';
 
 let isInstrumented = false;
 let originalHttpCreateServer = null;
@@ -28,6 +36,19 @@ function wrapRequestHandler(handler) {
   return function wrappedHandler(req, res) {
     const startTime = process.hrtime.bigint();
 
+    let span = null;
+    let spanEnded = false;
+    if (shouldEmitBunManualSpans()) {
+      try {
+        span = getBunTracer().startSpan('HTTP', { kind: SpanKind.SERVER });
+        span.setAttribute('http.method', req.method || 'GET');
+        const rawUrl = req.url || '/';
+        span.setAttribute('http.target', typeof rawUrl === 'string' ? rawUrl : String(rawUrl));
+      } catch {
+        span = null;
+      }
+    }
+
     // Store original end method
     const originalEnd = res.end;
 
@@ -46,13 +67,52 @@ function wrapRequestHandler(handler) {
       const aggregator = getAggregator();
       aggregator.recordRequest(method, route, latencyMs, isError);
 
+      if (span && !spanEnded) {
+        spanEnded = true;
+        try {
+          span.setAttribute('http.route', route);
+          span.setAttribute('http.status_code', statusCode);
+          span.updateName(`${method} ${route}`);
+          span.setStatus(
+            statusCode >= 400
+              ? { code: SpanStatusCode.ERROR }
+              : { code: SpanStatusCode.OK }
+          );
+        } catch {
+          /* ignore */
+        }
+        try {
+          span.end();
+        } catch {
+          /* ignore */
+        }
+      }
+
       debug(`Request: ${method} ${route} ${statusCode} ${latencyMs.toFixed(2)}ms`);
 
       // Call original end
       return originalEnd.apply(this, args);
     };
 
-    // Call original handler
+    if (span) {
+      try {
+        const ctx = trace.setSpan(context.active(), span);
+        return context.with(ctx, () => handler.call(this, req, res));
+      } catch (err) {
+        if (!spanEnded) {
+          spanEnded = true;
+          try {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: err?.message });
+            span.recordException(err);
+            span.end();
+          } catch {
+            /* ignore */
+          }
+        }
+        throw err;
+      }
+    }
+
     return handler.call(this, req, res);
   };
 }

package/src/traceSpanExporter.js

@@ -95,6 +95,27 @@ function shouldSampleTraceId(traceId, sampleRate) {
   }
 }
 
+function getParentSpanId(span) {
+  try {
+    const direct = span?.parentSpanId;
+    if (typeof direct === 'string' && direct) return direct;
+
+    const psc = span?.parentSpanContext;
+    if (psc && typeof psc === 'object') {
+      const id = psc.spanId;
+      if (typeof id === 'string' && id) return id;
+    }
+    if (typeof psc === 'function') {
+      const ctx = psc();
+      const id = ctx?.spanId;
+      if (typeof id === 'string' && id) return id;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
 function serializeSpan(span) {
   const ctx = span?.spanContext?.();
   if (!ctx?.traceId || !ctx?.spanId) return null;
@@ -103,7 +124,7 @@ function serializeSpan(span) {
   const endNano = hrTimeToUnixNanoString(span.endTime);
   if (!startNano || !endNano) return null;
 
-  const parentSpanId = span?.parentSpanId || span?.parentSpanContext?.spanId || null;
+  const parentSpanId = getParentSpanId(span);
   const status = statusForSpan(span);
 
   const durationMs =
@@ -146,13 +167,6 @@ export class SentienGuardTraceSpanExporter {
         }
       }
 
-      // #region agent log
-      try {
-        const first = serialized[0] || null;
-        console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'trace-export',hypothesisId:'F,H,I',location:'traceSpanExporter.js:export',message:'export() called',data:{receivedCount:Array.isArray(spans)?spans.length:0,sampledCount:serialized.length,sampleRate:rate,firstName:first?.name||null,firstKind:first?.kind||null,firstTraceId:first?.trace_id||null},timestamp:Date.now()}));
-      } catch {}
-      // #endregion
-
       if (serialized.length) {
         enqueueSpans(serialized);
       }

package/src/traceTransport.js

@@ -97,25 +97,14 @@ async function flushOnce(batch) {
   };
 
   try {
-    const startedAt = Date.now();
-    const res = await sendToBackend(payload);
+    await sendToBackend(payload);
     consecutiveFailures = 0;
     lastFailureAtMs = 0;
     debug(`Trace flush ok: spans=${batch.length}`);
-    // #region agent log
-    try {
-      console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'trace-send',hypothesisId:'G',location:'traceTransport.js:flushOnce',message:'sendToBackend SUCCESS',data:{spans:batch.length,statusCode:res?.statusCode||null,durationMs:Date.now()-startedAt,endpoint:cfg.tracesEndpoint},timestamp:Date.now()}));
-    } catch {}
-    // #endregion
   } catch (err) {
     consecutiveFailures++;
     lastFailureAtMs = Date.now();
     warn(`Trace flush failed (attempt ${consecutiveFailures}): ${err.message}`);
-    // #region agent log
-    try {
-      console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'trace-send',hypothesisId:'G',location:'traceTransport.js:flushOnce',message:'sendToBackend FAILED',data:{spans:batch.length,error:err?.message||String(err),consecutiveFailures,endpoint:cfg.tracesEndpoint},timestamp:Date.now()}));
-    } catch {}
-    // #endregion
     if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
       // Stop retrying aggressively; drop future spans until backend recovers.
       warn('Trace flush: max failures reached; dropping spans under backpressure');
@@ -165,12 +154,6 @@ export function enqueueSpans(serializedSpans) {
   const cfg = getConfig();
   const maxQueue = cfg.tracing?.maxQueueSize || 2048;
 
-  // #region agent log
-  try {
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'trace-enqueue',hypothesisId:'F,G',location:'traceTransport.js:enqueueSpans',message:'enqueueSpans called',data:{incomingCount:Array.isArray(serializedSpans)?serializedSpans.length:0,queueLenBefore:queue.length,maxQueue,sdkEnabled:isEnabled(),scheduled,consecutiveFailures},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   if (!Array.isArray(serializedSpans) || serializedSpans.length === 0) return;
   if (!isEnabled()) return;
 

package/src/tracing.js

@@ -193,11 +193,6 @@ export function startTracing() {
     sdk.start();
     tracingActive = true;
     debug('OpenTelemetry tracing started (W3C Trace Context + HTTP/Express)');
-    // #region agent log
-    try {
-      console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'trace-init',hypothesisId:'F,H,J',location:'tracing.js:startTracing',message:'tracing config snapshot',data:{isBun:typeof globalThis.Bun!=='undefined',tracingEnabled:cfg.tracing?.enabled,sampleRate:cfg.tracing?.sampleRate,maxQueueSize:cfg.tracing?.maxQueueSize,maxBatchSize:cfg.tracing?.maxBatchSize,endpoint:cfg.endpoint,tracesEndpoint:cfg.tracesEndpoint,service:cfg.service,environment:cfg.environment,apiKeyPresent:!!cfg.apiKey,apiKeyLen:cfg.apiKey?.length||0},timestamp:Date.now()}));
-    } catch {}
-    // #endregion
     return true;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);