@sentienguard/apm 1.0.22-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.22-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/index.js

@@ -80,12 +80,6 @@ function initialize() {
     instrumentDependencies();
   }
 
-  // #region agent log
-  try {
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'post-fix',hypothesisId:'A,B',location:'index.js:initialize',message:'SDK init runtime + instrumentation flow (Bun-aware)',data:{isBun:isBunRuntime,bunVersion:globalThis.Bun?.version||null,nodeVersion:process.versions?.node||null,tracingOn,legacyHttpInstalled:!tracingOn||isBunRuntime,service:config.service,endpoint:config.endpoint,argv0:process.argv0,execPath:process.execPath},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   // Auto-instrument MongoDB if available
   autoInstrumentMongoDB();
 

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/mongodb.js

@@ -106,12 +106,6 @@ function handleCommandStarted(event) {
 
   const commandName = event.commandName;
 
-  // #region agent log
-  try {
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'mongo-cmd',hypothesisId:'C',location:'mongodb.js:handleCommandStarted',message:'commandStarted event fired',data:{commandName,databaseName:event.databaseName,ignored:IGNORED_COMMANDS.has(commandName),requestId:String(event.requestId||'')},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   // Skip ignored commands
   if (IGNORED_COMMANDS.has(commandName)) {
     return;
@@ -269,42 +263,26 @@ function collectPoolStats() {
  * also populate require.cache via the CJS interop layer.
  */
 function tryDetectMongoose() {
-  let cacheKeyCount = 0;
-  let mongooseKeyMatched = null;
-  let cacheError = null;
   try {
     // Strategy 1: Scan require.cache for mongoose
     const cache = require.cache || {};
     const cacheKeys = Object.keys(cache);
-    cacheKeyCount = cacheKeys.length;
     const mongooseKey = cacheKeys.find(
       k => /[\\/]mongoose[\\/](?:lib[\\/])?index\.js$/.test(k) &&
            !k.includes('node_modules/mongoose/node_modules')
     );
-    mongooseKeyMatched = mongooseKey || null;
     if (mongooseKey && cache[mongooseKey]?.exports) {
       const mod = cache[mongooseKey].exports;
       // Verify it's actually mongoose (has connection property)
       if (mod.connection) {
         debug('Detected mongoose via require.cache');
-        // #region agent log
-        try {
-          console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'mongo-detect',hypothesisId:'D',location:'mongodb.js:tryDetectMongoose',message:'mongoose detected via require.cache',data:{isBun:typeof globalThis.Bun!=='undefined',cacheKeyCount,matchedKey:mongooseKey,readyState:mod.connection?.readyState??null},timestamp:Date.now()}));
-        } catch {}
-        // #endregion
         return mod;
       }
     }
   } catch (e) {
-    cacheError = e?.message || String(e);
+    // require.cache not available (unlikely in Node.js)
   }
 
-  // #region agent log
-  try {
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'mongo-detect',hypothesisId:'D',location:'mongodb.js:tryDetectMongoose',message:'mongoose NOT detected (require.cache scan)',data:{isBun:typeof globalThis.Bun!=='undefined',hasRequire:typeof require!=='undefined',hasRequireCache:typeof require!=='undefined' && !!require.cache,cacheKeyCount,mongooseKeyMatched,cacheError,globalThisMongoose:!!globalThis.mongoose},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   // Strategy 2: Fallback — check globalThis (in case user set it manually)
   try {
     if (globalThis.mongoose?.connection) {
@@ -328,14 +306,6 @@ function ensureMonitorCommands(client) {
       client.options?.monitorCommands ||
       client.s?.options?.monitorCommands;
 
-    // #region agent log
-    try {
-      const optsRoot = client.options ? Object.keys(client.options).slice(0, 30) : null;
-      const optsS = client.s?.options ? Object.keys(client.s.options).slice(0, 30) : null;
-      console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'mongo-init',hypothesisId:'C',location:'mongodb.js:ensureMonitorCommands',message:'monitorCommands inspection on live MongoClient',data:{alreadyEnabled:!!alreadyEnabled,hasClientOptions:!!client.options,hasClientSOptions:!!client.s?.options,clientOptionsFrozen:client.options ? Object.isFrozen(client.options) : null,clientSOptionsFrozen:client.s?.options ? Object.isFrozen(client.s.options) : null,optsRootKeys:optsRoot,optsSKeys:optsS},timestamp:Date.now()}));
-    } catch {}
-    // #endregion
-
     if (alreadyEnabled) {
       debug('monitorCommands already enabled');
       return true;
@@ -389,11 +359,6 @@ function wrapMongooseConnectForMonitorCommands(mongoose) {
       mongoose.connect = function sentienguardConnect(uri, options, ...rest) {
         const opts = { ...(options || {}), monitorCommands: true };
         debug('Injecting monitorCommands:true into mongoose.connect()');
-        // #region agent log
-        try {
-          console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'post-fix',hypothesisId:'C',location:'mongodb.js:wrapMongooseConnect',message:'mongoose.connect called - injected monitorCommands:true',data:{hadOptions:!!options,userMonitorCommands:options?.monitorCommands??null},timestamp:Date.now()}));
-        } catch {}
-        // #endregion
         return origConnect(uri, opts, ...rest);
       };
     }

package/src/spanExporter.js

@@ -146,12 +146,6 @@ export function classifyAndRecordSpan(span) {
   let error = isErrorSpan(span);
   const kind = span.kind;
 
-  // #region agent log
-  try {
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'span',hypothesisId:'A,E',location:'spanExporter.js:classifyAndRecordSpan',message:'span received by exporter',data:{kind,name:span.name,latencyMs:Math.round(latency),httpMethod:attr(attrs,HTTP_METHOD)||null,httpRoute:attr(attrs,HTTP_ROUTE)||null,httpTarget:attr(attrs,HTTP_TARGET)||null,httpStatus:attr(attrs,HTTP_STATUS)||null,dbSystem:attr(attrs,DB_SYSTEM)||null,dbCollection:attr(attrs,DB_COLLECTION)||null,dbOperation:attr(attrs,DB_OPERATION)||null,peerName:attr(attrs,NET_PEER_NAME)||null,error},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   if (kind === SpanKind.SERVER) {
     const method = attr(attrs, HTTP_METHOD) || 'GET';
     let route = attr(attrs, HTTP_ROUTE) || attr(attrs, HTTP_TARGET) || '/';

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 =

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:'init',hypothesisId:'A',location:'tracing.js:startTracing',message:'NodeSDK.start() returned without error',data:{isBun:typeof globalThis.Bun!=='undefined',sdkType:sdk?.constructor?.name||null,instrumentationsCount:4,sampler:'AlwaysOn'},timestamp:Date.now()}));
-    } catch {}
-    // #endregion
     return true;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);

package/src/transport.js

@@ -112,14 +112,6 @@ async function flush() {
 
   const aggregator = getAggregator();
 
-  // #region agent log
-  try {
-    const stats = aggregator.getStats();
-    const pool = aggregator.mongodbPoolStats || null;
-    console.log('[SG-APM-DBG]', JSON.stringify({sessionId:'ecc573',runId:'flush',hypothesisId:'A,B,C,D,E',location:'transport.js:flush',message:'flush() invoked - aggregator state',data:{hasData:aggregator.hasData(),...stats,poolUpdated:!!pool?.lastUpdated,poolActive:pool?.active??null,poolIdle:pool?.idle??null,poolTotal:pool?.total??null,isBun:typeof globalThis.Bun!=='undefined'},timestamp:Date.now()}));
-  } catch {}
-  // #endregion
-
   // Skip if no data
   if (!aggregator.hasData()) {
     debug('No data to flush');