@reproapp/node-sdk 0.0.38 → 0.0.41

package/src/ingest/client.ts

@@ -57,6 +57,7 @@ export const kickIngestQueueDrain = (): void => {
 };
 
 const isCriticalIngestEntry = (entry: LegacyEntry): boolean => (
+    entry.requestCaptureStart !== undefined ||
     entry.requestCaptureManifest !== undefined ||
     entry.sessionCaptureManifest !== undefined ||
     entry.request !== undefined ||

package/src/ingest/mapper.ts

@@ -7,6 +7,7 @@ const toIso = (timestamp: unknown): string => {
 };
 
 const inferEventType = (entry: LegacyEntry): string => {
+  if (entry.requestCaptureStart !== undefined) return 'request_capture_start';
   if (entry.requestCaptureManifest !== undefined) return 'request_capture_manifest';
   if (entry.sessionCaptureManifest !== undefined) return 'session_capture_manifest';
   if (entry.request !== undefined) return 'backend_request';

package/src/ingest/types.ts

@@ -18,6 +18,7 @@ export interface LegacyEntry {
     requestRid?: string | null;
     request?: unknown;
     requestValues?: unknown[];
+    requestCaptureStart?: unknown;
     requestCaptureManifest?: unknown;
     sessionCaptureManifest?: unknown;
     db?: unknown;

package/test/backend-live-mode.test.js

@@ -0,0 +1,421 @@
+const assert = require('assert');
+const express = require('express');
+const http = require('http');
+
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+
+const {
+  reproMiddleware,
+  __reproTestHooks,
+} = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+async function listen(server) {
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  return server.address().port;
+}
+
+async function close(server) {
+  await new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+async function request(port, path = '/untagged', options = {}) {
+  const method = options.method || 'POST';
+  const headers = {
+    ...(method === 'POST' ? { 'content-type': 'application/json' } : {}),
+    ...(options.headers || {}),
+  };
+  await new Promise((resolve, reject) => {
+    const req = http.request({
+      host: '127.0.0.1',
+      port,
+      path,
+      method,
+      headers,
+    }, (res) => {
+      res.resume();
+      res.on('end', resolve);
+    });
+    req.on('error', reject);
+    if (method === 'POST') {
+      req.end(JSON.stringify({ ok: true }));
+    } else {
+      req.end();
+    }
+  });
+}
+
+async function drainAll() {
+  await __reproTestHooks.drainSdkBackgroundQueueForTest();
+  await flushIngestQueue();
+}
+
+async function drainUntil(predicate, timeoutMs = 1000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    await drainAll();
+    if (predicate()) return true;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  await drainAll();
+  return predicate();
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+  const posts = [];
+  const claimCounts = new Map();
+  const originalFetch = global.fetch;
+  global.fetch = async (url, init = {}) => {
+    const body = init.body ? JSON.parse(String(init.body)) : null;
+    posts.push({ url: String(url), body, headers: init.headers || {} });
+    if (String(url) === 'http://repro-api.test/api/v1/live-sessions/claim') {
+      const actor = String(body?.actorId || 'unknown');
+      const count = (claimCounts.get(actor) || 0) + 1;
+      claimCounts.set(actor, count);
+      const safeActor = actor.replace(/[^A-Za-z0-9_.:-]/g, '_');
+      const childSuffix = actor === 'actor-overlap' ? `_${count}` : '';
+      const childSessionId = `S_claim_child_${safeActor}${childSuffix}`;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          parentSessionId: `S_claim_parent_${safeActor}`,
+          childSessionId,
+          sessionId: childSessionId,
+          actionId: `A_claim_${safeActor}_${count}`,
+          clockOffsetMs: 0,
+        }),
+        text: async () => '{"ok":true}',
+      };
+    }
+    return {
+      ok: true,
+      status: 202,
+      json: async () => ({ ok: true }),
+      text: async () => '{"ok":true}',
+    };
+  };
+
+  __reproTestHooks.resetSdkBackgroundQueuesForTest();
+  __reproTestHooks.setBackendLiveTimingForTest({
+    segmentIdleMs: 1,
+    sessionMaxDurationMs: 20,
+    segmentMaxDurationMs: 20,
+  });
+
+  const cfg = {
+    appId: 'APP_backend_live',
+    tenantId: 'TENANT_backend_live',
+    appSecret: 'secret',
+    appName: 'Backend Live Test',
+    serviceName: 'Backend API',
+    apiBase: 'http://repro-api.test/api',
+    ingestBase: 'http://log-collector.test',
+    liveMode: {
+      enabled: true,
+      backendOnly: true,
+      defineActorId: ({ req }) => req.headers['x-test-actor'] || 'actor-1',
+      shouldCapture: ({ path }) => path !== '/skip',
+      actorType: 'user',
+      actorLabels: { tier: 'enterprise' },
+    },
+  };
+
+  const app = express();
+  app.use(express.json());
+  app.use(reproMiddleware(cfg));
+  app.post('/untagged', (_req, res) => {
+    res.json({ ok: true });
+  });
+  const server = http.createServer(app);
+  const port = await listen(server);
+
+  try {
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        origin: 'http://client.test',
+        'access-control-request-method': 'POST',
+        'access-control-request-headers': 'x-bug-session-id,x-bug-action-id,x-bug-request-start',
+      },
+    });
+    await drainAll();
+    assert.equal(
+      posts.length,
+      0,
+      'uncorrelated OPTIONS preflight should not create live sessions or ingest events',
+    );
+
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        'x-bug-request-start': String(Date.now()),
+      },
+    });
+    await drainAll();
+    assert.equal(
+      posts.length,
+      0,
+      'OPTIONS with only Repro timing should not create backend-only live sessions',
+    );
+
+    const correlatedOptionsSid = 'S_frontend_options';
+    const correlatedOptionsAid = 'A_frontend_options';
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        'x-bug-session-id': correlatedOptionsSid,
+        'x-bug-action-id': correlatedOptionsAid,
+        'x-bug-request-start': String(Date.now()),
+      },
+    });
+    await drainUntil(() => {
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return events.some((event) =>
+        event.event_type === 'backend_request' &&
+        event.session_id === correlatedOptionsSid &&
+        event.payload?.action_id === correlatedOptionsAid
+      );
+    }, 2000);
+    assert(
+      posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : [])
+        .some((event) =>
+          event.event_type === 'backend_request' &&
+          event.session_id === correlatedOptionsSid &&
+          event.payload?.action_id === correlatedOptionsAid
+        ),
+      'correlated OPTIONS request should still be captured',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'frontend-correlated OPTIONS should not create a backend-only live parent',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim').length,
+      0,
+      'frontend-correlated OPTIONS should not claim a backend-only live session',
+    );
+
+    posts.length = 0;
+    const correlatedPostSid = 'S_frontend_post';
+    const correlatedPostAid = 'A_frontend_post';
+    await request(port, '/untagged', {
+      headers: {
+        'x-bug-session-id': correlatedPostSid,
+        'x-bug-action-id': correlatedPostAid,
+        'x-bug-request-start': String(Date.now()),
+        'x-test-actor': 'backend-user-1',
+      },
+    });
+    await drainUntil(() => {
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return events.some((event) =>
+        event.event_type === 'backend_event' &&
+        event.session_id === correlatedPostSid &&
+        event.payload?.sessionActor?.actorId === 'backend-user-1'
+      );
+    }, 2000);
+    const correlatedEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    assert(
+      correlatedEvents.some((event) =>
+        event.event_type === 'backend_event' &&
+        event.session_id === correlatedPostSid &&
+        event.actor_id === 'backend-user-1' &&
+        event.payload?.sessionActor?.actorId === 'backend-user-1'
+      ),
+      'frontend-correlated request should emit backend actor alias evidence',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'frontend-correlated request should not create backend-only live sessions',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim').length,
+      0,
+      'frontend-correlated request should not claim backend-only live sessions',
+    );
+
+    posts.length = 0;
+    await request(port);
+    await drainUntil(() => {
+      const claims = posts
+        .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+        .map((post) => post.body);
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return claims.length >= 1 &&
+        events.some((event) =>
+          event.event_type === 'request_capture_start' &&
+          event.session_id === 'S_claim_child_actor-1'
+        ) &&
+        events.some((event) =>
+          event.event_type === 'backend_request' &&
+          event.session_id === 'S_claim_child_actor-1'
+        ) &&
+        events.some((event) =>
+          event.event_type === 'request_capture_manifest' &&
+          event.session_id === 'S_claim_child_actor-1'
+        );
+    }, 2000);
+
+    const claims = posts
+      .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+      .map((post) => post.body);
+    assert.equal(claims.length, 1, 'backend-only request should claim one central live session');
+    assert.equal(claims[0].captureMode, 'backend-only');
+    assert.equal(claims[0].actorId, 'actor-1');
+    assert.deepEqual(claims[0].actorIds, ['actor-1']);
+
+    const ingestEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    assert(
+      ingestEvents.some((event) =>
+        event.event_type === 'request_capture_start' &&
+        event.session_id === 'S_claim_child_actor-1' &&
+        event.actor_id === 'actor-1'
+      ),
+      'request capture start should fence the claimed backend session',
+    );
+    assert(
+      ingestEvents.some((event) =>
+        event.event_type === 'backend_request' &&
+        event.session_id === 'S_claim_child_actor-1' &&
+        event.actor_id === 'actor-1'
+      ),
+      'backend request event should be captured for claimed child session and actor',
+    );
+    assert(
+      ingestEvents.some((event) =>
+        event.event_type === 'request_capture_manifest' &&
+        event.session_id === 'S_claim_child_actor-1'
+      ),
+      'request capture manifest should be emitted for claimed backend session',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'SDK should not locally create backend-only sessions after central claim',
+    );
+    assert.equal(
+      posts.some((post) => String(post.url).includes('/finish')),
+      false,
+      'SDK should not locally finish centrally claimed backend-only sessions',
+    );
+
+    console.log('backend live mode capture OK');
+  } finally {
+    await close(server);
+  }
+
+  posts.length = 0;
+  __reproTestHooks.resetSdkBackgroundQueuesForTest();
+  __reproTestHooks.setBackendLiveTimingForTest({
+    sessionMaxDurationMs: 30,
+    segmentMaxDurationMs: 30,
+    segmentIdleMs: 1,
+  });
+
+  const overlapCfg = {
+    ...cfg,
+    appId: 'APP_backend_live_overlap',
+    liveMode: {
+      ...cfg.liveMode,
+      defineActorId: () => 'actor-overlap',
+      shouldCapture: ({ path }) => path !== '/skip',
+    },
+  };
+
+  const overlapApp = express();
+  overlapApp.use(express.json());
+  overlapApp.use(reproMiddleware(overlapCfg));
+  overlapApp.post('/slow', async (_req, res) => {
+    await sleep(80);
+    res.json({ ok: true, kind: 'slow' });
+  });
+  overlapApp.post('/fast', (_req, res) => {
+    res.json({ ok: true, kind: 'fast' });
+  });
+  const overlapServer = http.createServer(overlapApp);
+  const overlapPort = await listen(overlapServer);
+
+  try {
+    const slowRequest = request(overlapPort, '/slow');
+    await sleep(50);
+    await request(overlapPort, '/fast');
+    await slowRequest;
+
+    await drainUntil(() => {
+      const claims = posts
+        .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim');
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      const requestSessionIds = new Set(
+        events
+          .filter((event) =>
+            event.event_type === 'backend_request' &&
+            event.actor_id === 'actor-overlap'
+          )
+          .map((event) => event.session_id),
+      );
+      return claims.length >= 2 && requestSessionIds.size >= 2;
+    });
+
+    const claims = posts
+      .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+      .map((post) => post.body);
+    assert.equal(claims.length, 2, 'each backend-only request should ask the API for ownership');
+    assert(
+      claims.every((claim) => claim.actorId === 'actor-overlap'),
+      'overlap claims should keep the actor identity',
+    );
+
+    const ingestEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    const requestSessionIds = new Set(
+      ingestEvents
+        .filter((event) =>
+          event.event_type === 'backend_request' &&
+          event.actor_id === 'actor-overlap'
+        )
+        .map((event) => event.session_id),
+    );
+    assert.deepEqual(
+      new Set(['S_claim_child_actor-overlap_1', 'S_claim_child_actor-overlap_2']),
+      requestSessionIds,
+      'backend requests should use exactly the child sessions returned by the API claim',
+    );
+
+    console.log('backend live mode central claim overlap OK');
+  } finally {
+    await close(overlapServer);
+    global.fetch = originalFetch;
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    __reproTestHooks.setBackendLiveTimingForTest(null);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});