testdriverai 7.8.0-test.68 → 7.8.0-test.69

package/agent/index.js

@@ -212,6 +212,14 @@ class TestDriverAgent extends EventEmitter2 {
       }
     }
 
+    // End the Sentry root session span so the trace is finalized
+    try {
+      const sentry = require("../lib/sentry");
+      sentry.clearSessionTraceContext(this.session && this.session.get());
+    } catch (e) {
+      // Sentry module may not be available, ignore
+    }
+
     shouldRunPostrun =
       !this.hasRunPostrun &&
       (shouldRunPostrun || this.cliArgs?.command == "run");

package/agent/lib/http.js

@@ -16,13 +16,31 @@ const { version } = require("../../package.json");
 const USER_AGENT = `TestDriverSDK/${version} (Node.js ${process.version})`;
 
 /**
- * Generate Sentry distributed-tracing headers from a session ID.
- * Both sandbox.js and sdk.js duplicated this — it now lives here.
+ * Generate Sentry distributed-tracing headers.
+ *
+ * When Sentry is initialized and a span is active, uses Sentry.getTraceData()
+ * so the headers reference the real active span (proper parent-child linkage).
+ * Falls back to MD5(sessionId)-based headers when Sentry is not available or
+ * has no active span (e.g. TD_TELEMETRY=false).
  *
  * @param {string} sessionId
- * @returns {object} Headers object (empty if no sessionId)
+ * @returns {object} Headers object (empty if no sessionId and no active span)
  */
 function getSentryTraceHeaders(sessionId) {
+  // Prefer Sentry's own trace propagation when available
+  try {
+    const Sentry = require("@sentry/node");
+    if (typeof Sentry.getTraceData === "function") {
+      const traceData = Sentry.getTraceData();
+      if (traceData && traceData["sentry-trace"]) {
+        return traceData;
+      }
+    }
+  } catch (e) {
+    // Sentry not available — fall through to manual derivation
+  }
+
+  // Fallback: derive deterministic trace from session ID
   if (!sessionId) return {};
   const traceId = crypto.createHash("md5").update(sessionId).digest("hex");
   const spanId = crypto.randomBytes(8).toString("hex");

package/agent/lib/sandbox.js

@@ -570,13 +570,16 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         if (needsReadyWait) {
           logger.log('Waiting for runner agent to signal readiness...');
           // E2B (Linux) sandboxes need extra time: S3 upload + npm install can add 60-120s on top of sandbox boot
-          var readyTimeout = isE2B ? 300000 : 120000; // 5 min for E2B (S3+npm), 2 min for EC2
+          // EC2 (Windows) cold starts can be slow due to AV scanning and native module loading
+          var readyTimeout = isE2B ? 300000 : 180000; // 5 min for E2B (S3+npm), 3 min for EC2
           await new Promise(function (resolve, reject) {
             var resolved = false;
+            var waitStart = Date.now();
             function finish(data) {
               if (resolved) return;
               resolved = true;
               clearTimeout(timer);
+              clearInterval(progressTimer);
               self._sessionChannel.unsubscribe('control', onCtrl);
               // Update runner info if provided
               if (data && data.os) reply.runner = reply.runner || {};
@@ -613,6 +616,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             var timer = setTimeout(function () {
               if (!resolved) {
                 resolved = true;
+                clearInterval(progressTimer);
                 self._sessionChannel.unsubscribe('control', onCtrl);
                 var err = new Error('Runner agent did not signal readiness within ' + readyTimeout + 'ms');
                 sentry.captureException(err, {
@@ -624,6 +628,13 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             }, readyTimeout);
             if (timer.unref) timer.unref();
 
+            // Log progress every 15s so the user knows we're still waiting
+            var progressTimer = setInterval(function () {
+              if (resolved) return;
+              var elapsed = Math.round((Date.now() - waitStart) / 1000);
+              logger.log('Still waiting for runner agent... (' + elapsed + 's elapsed, timeout=' + Math.round(readyTimeout / 1000) + 's)');
+            }, 15000);
+
             // Listen for live runner.ready messages
             var onCtrl;
             onCtrl = function (msg) {
@@ -722,13 +733,15 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         var self = this;
         if (reply.agent && this._sessionChannel) {
           logger.log('Waiting for runner agent to signal readiness (direct connection)...');
-          var readyTimeout = 120000; // 120s — allows for SSM provisioning + agent startup
+          var readyTimeout = 180000; // 180s — Windows cold starts can be slow (AV scanning, native module loading)
           await new Promise(function (resolve, reject) {
             var resolved = false;
+            var waitStart = Date.now();
             function finish(data) {
               if (resolved) return;
               resolved = true;
               clearTimeout(timer);
+              clearInterval(progressTimer);
               self._sessionChannel.unsubscribe('control', onCtrl);
               logger.log('Runner agent ready (direct, os=' + ((data && data.os) || 'unknown') + ', runner v' + ((data && data.runnerVersion) || 'unknown') + ')');
               if (data && data.update) {
@@ -749,6 +762,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             var timer = setTimeout(function () {
               if (!resolved) {
                 resolved = true;
+                clearInterval(progressTimer);
                 self._sessionChannel.unsubscribe('control', onCtrl);
                 var err = new Error('Runner agent did not signal readiness within ' + readyTimeout + 'ms (direct connection)');
                 sentry.captureException(err, {
@@ -760,6 +774,13 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             }, readyTimeout);
             if (timer.unref) timer.unref();
 
+            // Log progress every 15s so the user knows we're still waiting
+            var progressTimer = setInterval(function () {
+              if (resolved) return;
+              var elapsed = Math.round((Date.now() - waitStart) / 1000);
+              logger.log('Still waiting for runner agent... (' + elapsed + 's elapsed, timeout=' + Math.round(readyTimeout / 1000) + 's)');
+            }, 15000);
+
             // Listen for live runner.ready messages
             var onCtrl;
             onCtrl = function (msg) {

package/agent/lib/sdk.js

@@ -1,5 +1,5 @@
 const { events } = require("../events");
-const crypto = require("crypto");
+const { getSentryTraceHeaders } = require("./http");
 
 // get the version from package.json
 const { version } = require("../../package.json");
@@ -114,25 +114,6 @@ async function withRetry(fn, options = {}) {
   throw lastError;
 }
 
-/**
- * Generate Sentry trace headers for distributed tracing
- * Uses the same trace ID derivation as the API (MD5 hash of session ID)
- * @param {string} sessionId - The session ID
- * @returns {Object} Headers object with sentry-trace and baggage
- */
-function getSentryTraceHeaders(sessionId) {
-  if (!sessionId) return {};
-  
-  // Same logic as API: derive trace ID from session ID
-  const traceId = crypto.createHash('md5').update(sessionId).digest('hex');
-  const spanId = crypto.randomBytes(8).toString('hex');
-  
-  return {
-    'sentry-trace': `${traceId}-${spanId}-1`,
-    'baggage': `sentry-trace_id=${traceId},sentry-sample_rate=1.0,sentry-sampled=true`
-  };
-}
-
 // Factory function that creates SDK with the provided emitter, config, and session
 let token = null;
 const createSDK = (emitter, config, sessionInstance) => {

package/examples/exec-stream-logs.test.mjs

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+import { getDefaults } from "./config.mjs";
+
+describe("Exec Log Streaming", () => {
+  it("should stream exec logs every second for 20 seconds", async (context) => {
+    const testdriver = TestDriver(context, { ...getDefaults(context), headless: true });
+    await testdriver.provision.chrome({ url: "about:blank" });
+
+    const code = `for i in $(seq 1 20); do echo "log line $i at $(date +%T)"; sleep 1; done`;
+
+    const result = await testdriver.exec({
+      language: "sh",
+      code,
+      timeout: 30000,
+    });
+
+    console.log("exec result:", result);
+
+    // Verify we got all 20 log lines
+    for (let i = 1; i <= 20; i++) {
+      expect(result).toContain(`log line ${i}`);
+    }
+  });
+});

package/lib/sentry.js

@@ -180,18 +180,41 @@ function captureMessage(message, level = "info") {
 }
 
 /**
- * Set the session trace context for distributed tracing
- * This links CLI errors/logs to the same trace as API calls
+ * Set the session trace context for distributed tracing.
+ * Creates a root span (sdk.session) that appears in the Sentry trace waterfall
+ * and sets propagation context so all outbound headers (HTTP and Ably) reference
+ * the same deterministic traceId = MD5(sessionId).
+ *
  * @param {string} sessionId - The session ID
  */
 function setSessionTraceContext(sessionId) {
   if (!isEnabled() || !sessionId) return;
 
-  // Derive trace ID from session ID (same algorithm as API)
+  // Derive trace ID from session ID (same algorithm as API and Runner)
   const traceId = crypto.createHash("md5").update(sessionId).digest("hex");
 
-  // Store per-session trace context for concurrent safety
-  _traceContexts.set(sessionId, { traceId, sessionId });
+  // Build a synthetic sentry-trace header to seed the trace with our deterministic ID
+  const spanId = crypto.randomBytes(8).toString("hex");
+  const sentryTraceHeader = `${traceId}-${spanId}-1`;
+  const baggageHeader = `sentry-trace_id=${traceId},sentry-sampled=true`;
+
+  // continueTrace sets the scope's propagation context so all subsequent
+  // getTraceData() calls return our traceId. startInactiveSpan creates a
+  // root transaction that will be visible in the Sentry trace waterfall.
+  let rootSpan = null;
+  Sentry.continueTrace(
+    { sentryTrace: sentryTraceHeader, baggage: baggageHeader },
+    () => {
+      rootSpan = Sentry.startInactiveSpan({
+        name: "sdk.session",
+        op: "session",
+        forceTransaction: true,
+      });
+    },
+  );
+
+  // Store per-session trace context (including root span for cleanup)
+  _traceContexts.set(sessionId, { traceId, sessionId, rootSpan });
 
   // Also update the module-level "latest" for backward compatibility
   currentTraceId = traceId;
@@ -200,28 +223,17 @@ function setSessionTraceContext(sessionId) {
   // Set as global tag so all events include it
   Sentry.setTag("session", sessionId);
   Sentry.setTag("trace_id", currentTraceId);
-
-  // Try to set propagation context for trace linking (may not be available in all versions)
-  try {
-    const scope = Sentry.getCurrentScope();
-    if (scope && typeof scope.setPropagationContext === "function") {
-      scope.setPropagationContext({
-        traceId: currentTraceId,
-        spanId: currentTraceId.substring(0, 16),
-        sampled: true,
-      });
-    }
-  } catch (e) {
-    // Ignore errors - propagation context may not be supported
-    logger.log("Could not set propagation context:", e.message);
-  }
 }
 
 /**
- * Clear the session trace context
+ * Clear the session trace context and end the root session span.
  */
 function clearSessionTraceContext(sessionId) {
   if (sessionId) {
+    const ctx = _traceContexts.get(sessionId);
+    if (ctx && ctx.rootSpan) {
+      try { ctx.rootSpan.end(); } catch (e) { /* ignore */ }
+    }
     _traceContexts.delete(sessionId);
     // If the cleared session was the "latest", pick another or null
     if (currentSessionId === sessionId) {
@@ -235,7 +247,12 @@ function clearSessionTraceContext(sessionId) {
       }
     }
   } else {
-    // Clear all (backward compatibility)
+    // Clear all (backward compatibility) — end all root spans
+    for (const ctx of _traceContexts.values()) {
+      if (ctx.rootSpan) {
+        try { ctx.rootSpan.end(); } catch (e) { /* ignore */ }
+      }
+    }
     _traceContexts.clear();
     currentTraceId = null;
     currentSessionId = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "7.8.0-test.68",
+  "version": "7.8.0-test.69",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",

package/test-sentry-span.js

@@ -0,0 +1,35 @@
+const Sentry = require('@sentry/node');
+const crypto = require('crypto');
+
+Sentry.init({ dsn: 'https://test@sentry.io/123', tracesSampleRate: 1.0 });
+
+const sessionId = 'test-session-123';
+const traceId = crypto.createHash('md5').update(sessionId).digest('hex');
+console.log('expected traceId:', traceId);
+
+const sentryTraceHeader = traceId + '-' + crypto.randomBytes(8).toString('hex') + '-1';
+const baggageHeader = 'sentry-trace_id=' + traceId + ',sentry-sampled=true';
+
+// Approach: Use continueTrace + startInactiveSpan for the root, then rely on scope
+// for getTraceData propagation
+Sentry.continueTrace(
+  { sentryTrace: sentryTraceHeader, baggage: baggageHeader },
+  () => {
+    // This sets propagation context on the current scope
+    const rootSpan = Sentry.startInactiveSpan({ name: 'sdk.session', op: 'session', forceTransaction: true });
+    
+    // After continueTrace returns, check if getTraceData still uses the right traceId
+    const td = Sentry.getTraceData();
+    console.log('after continueTrace getTraceData:', JSON.stringify(td));
+    console.log('traceId matches:', td['sentry-trace'] && td['sentry-trace'].startsWith(traceId));
+    
+    // Simulate async: do a child span later
+    setTimeout(() => {
+      const td2 = Sentry.getTraceData();
+      console.log('async getTraceData:', JSON.stringify(td2));
+      console.log('async traceId matches:', td2['sentry-trace'] && td2['sentry-trace'].startsWith(traceId));
+      rootSpan.end();
+      process.exit(0);
+    }, 100);
+  }
+);