api.spec.ts

import { display } from '@datadog/browser-core'
import { mockClock, registerCleanupTask } from '@datadog/browser-core/test'
import { onEntry, onReturn, onThrow, initDebuggerTransport, resetDebuggerTransport } from './api'
import { addProbe, removeProbe, getProbes, clearProbes } from './probes'
import type { Probe } from './probes'

describe('api', () => {
  let mockBatchAdd: jasmine.Spy
  let warnSpy: jasmine.Spy

  function initTransport(overrides: Record<string, unknown> = {}) {
    resetDebuggerTransport()
    initDebuggerTransport(
      { service: 'test-service', env: 'test-env', ...overrides } as any,
      {
        add: mockBatchAdd,
      } as any
    )
  }

  beforeEach(() => {
    clearProbes()

    warnSpy = spyOn(display, 'warn')
    mockBatchAdd = jasmine.createSpy('batchAdd')
    initTransport()
    ;(window as any).DD_DEBUGGER = {
      version: '0.0.1',
    }

    registerCleanupTask(() => {
      delete (window as any).DD_DEBUGGER
      resetDebuggerTransport()
      clearProbes()
    })
  })

  describe('onEntry and onReturn', () => {
    it('should capture this inside arguments.fields', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'testMethod' },
        template: 'Test message',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const self = { name: 'testObj' }
      const args = { a: 1, b: 2 }
      const probes = getProbes('TestClass;testMethod')!
      onEntry(probes, self, args)
      onReturn(probes, 'result', self, args, {})

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot

      // Verify entry.arguments structure - now flat
      expect(snapshot.captures.entry.arguments).toEqual({
        a: { type: 'number', value: '1' },
        b: { type: 'number', value: '2' },
        this: {
          type: 'Object',
          fields: {
            name: { type: 'string', value: 'testObj' },
          },
        },
      })

      // Verify return.arguments structure - now flat
      expect(snapshot.captures.return.arguments).toEqual({
        a: { type: 'number', value: '1' },
        b: { type: 'number', value: '2' },
        this: {
          type: 'Object',
          fields: {
            name: { type: 'string', value: 'testObj' },
          },
        },
      })

      // Verify return.locals structure - also flat
      expect(snapshot.captures.return.locals['@return']).toEqual({
        type: 'string',
        value: 'result',
      })
    })

    it('should capture entry and return for simple probe', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'testMethod' },
        template: 'Test message',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const self = { name: 'test' }
      const args = { arg1: 'value1', arg2: 42 }

      const probes = getProbes('TestClass;testMethod')!
      onEntry(probes, self, args)
      const result = onReturn(probes, 'returnValue', self, args, {})

      expect(result).toBe('returnValue')
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      expect(payload.message).toBe('Test message')
      expect(payload.debugger.snapshot).toEqual(
        jasmine.objectContaining({ id: jasmine.any(String), captures: jasmine.any(Object) })
      )
    })

    it('should skip probe if sampling budget exceeded', () => {
      // Use a very low sampling rate to ensure budget is exceeded
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'budgetTest' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: 0.5 }, // 0.5 per second = 2000ms between samples
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;budgetTest')!
      // First call should work
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      // Second immediate call should be skipped (less than 2000ms passed)
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})

      // Still only one call because sampling budget not refreshed
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })

    it('should evaluate condition at ENTRY', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'conditionEntry' },
        when: {
          dsl: 'x > 5',
          json: { gt: [{ ref: 'x' }, 5] },
        },
        template: 'Condition passed',
        captureSnapshot: false,
        capture: {},
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      let probes = getProbes('TestClass;conditionEntry')!
      // Should fire when condition passes
      onEntry(probes, {}, { x: 10 })
      onReturn(probes, null, {}, { x: 10 }, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      clearProbes()
      addProbe(probe)
      mockBatchAdd.calls.reset()

      probes = getProbes('TestClass;conditionEntry')!
      // Should not fire when condition fails
      onEntry(probes, {}, { x: 3 })
      onReturn(probes, null, {}, { x: 3 }, {})
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should evaluate condition at EXIT with @return', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'conditionExit' },
        when: {
          dsl: '@return > 10',
          json: { gt: [{ ref: '@return' }, 10] },
        },
        template: 'Return value check',
        captureSnapshot: false,
        capture: {},
        sampling: {},
        evaluateAt: 'EXIT',
      }
      addProbe(probe)

      let probes = getProbes('TestClass;conditionExit')!
      // Should fire when return value > 10
      onEntry(probes, {}, {})
      onReturn(probes, 15, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      clearProbes()
      addProbe(probe)
      mockBatchAdd.calls.reset()

      probes = getProbes('TestClass;conditionExit')!
      // Should not fire when return value <= 10
      onEntry(probes, {}, {})
      onReturn(probes, 5, {}, {}, {})
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    // TODO: Validate that this test is actually correct
    it('should capture entry snapshot only for ENTRY evaluation with no condition', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'entrySnapshot' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;entrySnapshot')!
      onEntry(probes, { name: 'obj' }, { arg: 'value' })
      onReturn(probes, 'result', { name: 'obj' }, { arg: 'value' }, { local: 'data' })

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot
      expect(snapshot.captures).toEqual({
        entry: {
          arguments: {
            arg: { type: 'string', value: 'value' },
            this: { type: 'Object', fields: { name: { type: 'string', value: 'obj' } } },
          },
        },
        return: {
          arguments: {
            arg: { type: 'string', value: 'value' },
            this: { type: 'Object', fields: { name: { type: 'string', value: 'obj' } } },
          },
          locals: {
            local: { type: 'string', value: 'data' },
            '@return': { type: 'string', value: 'result' },
          },
        },
      })
    })

    it('should only capture return snapshot for EXIT evaluation with condition', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'exitSnapshot' },
        when: {
          dsl: '@return === true',
          json: { eq: [{ ref: '@return' }, true] },
        },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'EXIT',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;exitSnapshot')!
      onEntry(probes, {}, { arg: 'value' })
      onReturn(probes, true, {}, { arg: 'value' }, {})

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot
      expect(snapshot.captures.entry).toBeUndefined()
      expect(snapshot.captures.return).toBeDefined()
    })

    it('should include duration in snapshot', () => {
      const clock = mockClock()

      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'durationTest' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;durationTest')!
      onEntry(probes, {}, {})

      clock.tick(10)

      onReturn(probes, null, {}, {}, {})

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot
      expect(snapshot.duration).toBe(10_000_000) // Should be in nanoseconds (10ms)
    })
  })

  describe('onThrow', () => {
    it('should capture this inside arguments.fields for exceptions', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'throwTest' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const self = { name: 'testObj' }
      const args = { a: 1, b: 2 }
      const error = new Error('Test error')
      const probes = getProbes('TestClass;throwTest')!
      onEntry(probes, self, args)
      onThrow(probes, error, self, args)

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot

      // Verify return.arguments structure - now flat
      expect(snapshot.captures.return.arguments).toEqual({
        a: { type: 'number', value: '1' },
        b: { type: 'number', value: '2' },
        this: {
          type: 'Object',
          fields: {
            name: { type: 'string', value: 'testObj' },
          },
        },
      })

      // Verify throwable is still present
      expect(snapshot.captures.return.throwable).toEqual({
        message: 'Test error',
        stacktrace: jasmine.any(Array),
      })
      for (const frame of snapshot.captures.return.throwable.stacktrace) {
        expect(frame).toEqual(
          jasmine.objectContaining({
            fileName: jasmine.any(String),
            function: jasmine.any(String),
            lineNumber: jasmine.any(Number),
            columnNumber: jasmine.any(Number),
          })
        )
      }
    })

    it('should capture exception details', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'throwTest' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;throwTest')!
      const error = new Error('Test error')
      onEntry(probes, {}, { arg: 'value' })
      onThrow(probes, error, {}, { arg: 'value' })

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      const payload = mockBatchAdd.calls.mostRecent().args[0]
      const snapshot = payload.debugger.snapshot
      expect(snapshot.captures.return.throwable).toEqual({
        message: 'Test error',
        stacktrace: jasmine.any(Array),
      })
      for (const frame of snapshot.captures.return.throwable.stacktrace) {
        expect(frame).toEqual(
          jasmine.objectContaining({
            fileName: jasmine.any(String),
            function: jasmine.any(String),
            lineNumber: jasmine.any(Number),
            columnNumber: jasmine.any(Number),
          })
        )
      }
    })

    it('should evaluate EXIT condition with @exception', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'exceptionCondition' },
        when: {
          dsl: '@exception.message',
          json: { getmember: [{ ref: '@exception' }, 'message'] },
        },
        template: 'Exception captured',
        captureSnapshot: false,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'EXIT',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;exceptionCondition')!
      const error = new Error('Test error')
      onEntry(probes, {}, {})
      onThrow(probes, error, {}, {})

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })

    it('should handle onThrow without preceding onEntry', () => {
      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'throwWithoutEntry' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;throwWithoutEntry')!
      const error = new Error('Test error')
      onThrow(probes, error, {}, {})

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })
  })

  describe('global snapshot budget', () => {
    it('should respect global snapshot rate limit', () => {
      const probes: Probe[] = []
      for (let i = 0; i < 30; i++) {
        const probe: Probe = {
          id: `probe-${i}`,
          version: 0,
          type: 'LOG_PROBE',
          where: { typeName: 'TestClass', methodName: `method${i}` },
          template: 'Test',
          captureSnapshot: true,
          capture: {},
          sampling: { snapshotsPerSecond: 5000 },
          evaluateAt: 'ENTRY',
        }
        addProbe(probe)
        probes.push(probe)
      }

      // Try to fire 30 probes rapidly
      for (let i = 0; i < 30; i++) {
        const probes = getProbes(`TestClass;method${i}`)!
        onEntry(probes, {}, {})
        onReturn(probes, null, {}, {}, {})
      }

      // Should only get 25 calls (global limit)
      expect(mockBatchAdd).toHaveBeenCalledTimes(25)
    })

    it('should respect configured global snapshot rate limit', () => {
      initTransport({ maxSnapshotsPerSecondGlobally: 2 })

      for (let i = 0; i < 3; i++) {
        const probe: Probe = {
          id: `configured-global-probe-${i}`,
          version: 0,
          type: 'LOG_PROBE',
          where: { typeName: 'TestClass', methodName: `configuredGlobal${i}` },
          template: 'Test',
          captureSnapshot: true,
          capture: {},
          sampling: { snapshotsPerSecond: 5000 },
          evaluateAt: 'ENTRY',
        }
        addProbe(probe)
      }

      for (let i = 0; i < 3; i++) {
        const probes = getProbes(`TestClass;configuredGlobal${i}`)!
        onEntry(probes, {}, {})
        onReturn(probes, null, {}, {}, {})
      }

      expect(mockBatchAdd).toHaveBeenCalledTimes(2)
    })
  })

  describe('configured per-second budgets', () => {
    it('should respect configured default snapshot per-probe rate limit', () => {
      initTransport({ maxSnapshotsPerSecondPerProbe: 0.5 })

      const probe: Probe = {
        id: 'configured-snapshot-rate-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'configuredSnapshotRate' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;configuredSnapshotRate')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })

    it('should respect configured default non-snapshot per-probe rate limit', () => {
      initTransport({ maxNonSnapshotsPerSecondPerProbe: 1 })

      const probe: Probe = {
        id: 'configured-non-snapshot-rate-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'configuredNonSnapshotRate' },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;configuredNonSnapshotRate')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })
  })

  describe('probe lifetime budgets', () => {
    it('should stop sending snapshot events after maxSnapshotsPerProbeLifetime', () => {
      initTransport({ maxSnapshotsPerProbeLifetime: 1 })

      const probe: Probe = {
        id: 'snapshot-lifetime-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'snapshotLifetime' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        // Disable per-probe rate limiting so the second invocation exercises the
        // lifetime cap rather than the per-second cap.
        sampling: { snapshotsPerSecond: Infinity },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      // First invocation: probe sends its single allowed event.
      const probes = getProbes('TestClass;snapshotLifetime')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      // Second invocation: the lifetime budget is now exhausted. No new event should
      // be queued, and the probe should be auto-unregistered.
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
      expect(getProbes('TestClass;snapshotLifetime')).toBeUndefined()
    })

    it('should skip snapshot collection once the lifetime budget is exhausted', () => {
      initTransport({ maxSnapshotsPerProbeLifetime: 1 })

      const getterSpy = jasmine.createSpy('argGetter').and.returnValue('value')
      const args = {}
      Object.defineProperty(args, 'arg', {
        enumerable: true,
        get: getterSpy,
      })
      const probe: Probe = {
        id: 'snapshot-lifetime-collection-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'snapshotLifetimeCollection' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        // Disable per-probe rate limiting so the second invocation isn't sampled out
        // by it — we want to exercise the lifetime cap, not the rate cap.
        sampling: { snapshotsPerSecond: Infinity },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      // First invocation does the full pipeline: 2 reads from entry capture
      // (context spread + captureFields) + 1 read from return capture = 3 reads.
      // This exhausts the lifetime budget.
      const probes = getProbes('TestClass;snapshotLifetimeCollection')!
      onEntry(probes, {}, args)
      onReturn(probes, null, {}, args, {})

      // Second invocation: both onEntry and onReturn detect the exhausted budget
      // up front and skip all capture work — no further reads from args.
      onEntry(probes, {}, args)
      onReturn(probes, null, {}, args, {})

      expect(getterSpy).toHaveBeenCalledTimes(3)
    })

    it('should stop sending non-snapshot events after maxNonSnapshotsPerProbeLifetime', () => {
      initTransport({ maxNonSnapshotsPerProbeLifetime: 1 })

      const probe: Probe = {
        id: 'non-snapshot-lifetime-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'nonSnapshotLifetime' },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        // Disable per-probe rate limiting so the second invocation exercises the
        // lifetime cap rather than the per-second cap.
        sampling: { snapshotsPerSecond: Infinity },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      // First invocation: probe sends its single allowed event.
      const probes = getProbes('TestClass;nonSnapshotLifetime')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      // Second invocation: the lifetime budget is now exhausted. No new event should
      // be queued, and the probe should be auto-unregistered.
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
      expect(getProbes('TestClass;nonSnapshotLifetime')).toBeUndefined()
    })

    it('should reset the lifetime budget when a new probe version is delivered', () => {
      initTransport({ maxSnapshotsPerProbeLifetime: 1 })

      const probe: Probe = {
        id: 'versioned-lifetime-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'versionedLifetime' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      let probes = getProbes('TestClass;versionedLifetime')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      // A Remote Config delivery for an existing probe id replaces the old probe with
      // the new version. After re-add, the new version should have a fresh budget.
      removeProbe(probe.id)
      addProbe({ ...probe, version: 1 })

      probes = getProbes('TestClass;versionedLifetime')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(2)
    })

    it('should not emit any event when the lifetime budget is zero', () => {
      initTransport({ maxSnapshotsPerProbeLifetime: 0 })

      const probe: Probe = {
        id: 'zero-budget-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'zeroBudget' },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;zeroBudget')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})

      expect(mockBatchAdd).not.toHaveBeenCalled()
      expect(getProbes('TestClass;zeroBudget')).toBeUndefined()
    })

    it('should still process sibling probes when one is removed mid-iteration', () => {
      // Use distinct snapshot/non-snapshot lifetime caps so probeA hits its cap after
      // one event while probeB still has plenty of budget. On the second invocation,
      // probeA's pre-call budget check fails and it gets removed from the shared
      // probes array. This exposes the array mutation hazard: removing probeA
      // mid-iteration must not cause probeB to be skipped.
      initTransport({ maxSnapshotsPerProbeLifetime: 1, maxNonSnapshotsPerProbeLifetime: 1000 })

      // Disable per-probe rate limiting on both probes so the second invocation
      // exercises the lifetime cap rather than the per-second cap.
      const probeA: Probe = {
        id: 'sibling-probe-a',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'sibling' },
        template: 'A',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 1 },
        sampling: { snapshotsPerSecond: Infinity },
        evaluateAt: 'ENTRY',
      }
      const probeB: Probe = {
        id: 'sibling-probe-b',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'sibling' },
        template: 'B',
        captureSnapshot: false,
        capture: {},
        sampling: { snapshotsPerSecond: Infinity },
        evaluateAt: 'ENTRY',
      }
      addProbe(probeA)
      addProbe(probeB)

      // First invocation: both probes emit one event. probeA hits its cap (eventsSent=1,
      // max=1) but is not removed yet — the pre-call budget check still passed.
      const probes = getProbes('TestClass;sibling')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(2)

      // Second invocation: probeA's pre-call check now fails and it is queued for
      // removal. probeB must still be processed in the same iteration even though
      // probeA gets spliced out of the probes array.
      mockBatchAdd.calls.reset()
      const probesAfterFirst = getProbes('TestClass;sibling')!
      onEntry(probesAfterFirst, {}, {})
      onReturn(probesAfterFirst, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
      expect(getProbes('TestClass;sibling')).toEqual([jasmine.objectContaining({ id: 'sibling-probe-b' })])

      // probeB's stack entry must not leak: a third onReturn without onEntry is a no-op.
      mockBatchAdd.calls.reset()
      const remainingProbes = getProbes('TestClass;sibling')!
      onReturn(remainingProbes, null, {}, {}, {})
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })
  })

  describe('active entries cleanup', () => {
    function createProbe(id: string, methodName: string): Probe {
      return {
        id,
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
    }

    it('should discard in-flight entries when a probe is removed', () => {
      const probe = createProbe('cleanup-probe', 'cleanupTest')
      addProbe(probe)

      const probes = getProbes('TestClass;cleanupTest')!
      onEntry(probes, {}, {})

      removeProbe('cleanup-probe')
      addProbe(probe)

      const newProbes = getProbes('TestClass;cleanupTest')!
      onReturn(newProbes, null, {}, {}, {})

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should discard in-flight entries when all probes are cleared', () => {
      const probe = createProbe('cleanup-probe', 'clearAllTest')
      addProbe(probe)

      const probes = getProbes('TestClass;clearAllTest')!
      onEntry(probes, {}, {})

      clearProbes()
      addProbe(probe)

      const newProbes = getProbes('TestClass;clearAllTest')!
      onReturn(newProbes, null, {}, {}, {})

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should not leak active entries after onReturn completes', () => {
      const probe = createProbe('leak-probe', 'leakTest')
      addProbe(probe)

      const probes = getProbes('TestClass;leakTest')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      mockBatchAdd.calls.reset()

      // A second onReturn without onEntry should not produce a snapshot
      onReturn(probes, null, {}, {}, {})
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should not leak active entries after onThrow completes', () => {
      const probe = createProbe('throw-leak-probe', 'throwLeakTest')
      addProbe(probe)

      const probes = getProbes('TestClass;throwLeakTest')!
      onEntry(probes, {}, {})
      onThrow(probes, new Error('test'), {}, {})
      expect(mockBatchAdd).toHaveBeenCalledTimes(1)

      mockBatchAdd.calls.reset()

      // A second onThrow without onEntry should not produce a snapshot
      onThrow(probes, new Error('test'), {}, {})
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })
  })

  describe('snapshot timeout', () => {
    function createSnapshotProbe(methodName: string): Probe {
      return {
        id: `timeout-probe-${methodName}`,
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName },
        template: 'Test',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 3 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
    }

    it('should drop snapshot when entry capture exceeds timeout', () => {
      const probe = createSnapshotProbe('entryTimeout')
      addProbe(probe)

      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        // Let the first few calls (start time, deadline creation) use real time,
        // then jump past the deadline to simulate slow capture.
        if (callCount <= 3) {
          return realNow()
        }
        return realNow() + 20
      })

      const probes = getProbes('TestClass;entryTimeout')!
      const deepObj = { level1: { level2: { level3: { level4: 'deep' } } } }
      onEntry(probes, {}, { arg: deepObj })
      onReturn(probes, null, {}, { arg: deepObj }, {})

      // The entry capture timed out, so onEntry pushed null.
      // onReturn still gets an active entry from its own onEntry call, but
      // the entry snapshot is dropped. The return capture has its own timeout.
      // Since performance.now is still returning future values, the return
      // capture also times out and no snapshot is sent.
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should drop snapshot when return capture exceeds timeout', () => {
      const probe = createSnapshotProbe('returnTimeout')
      addProbe(probe)

      const probes = getProbes('TestClass;returnTimeout')!

      // Let onEntry succeed with real time
      onEntry(probes, {}, { x: 1 })

      // Now make performance.now jump forward so the return capture times out
      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (callCount <= 2) {
          return realNow()
        }
        return realNow() + 20
      })

      onReturn(probes, null, {}, { x: 1 }, { local: 'value' })

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should drop snapshot when throw capture exceeds timeout', () => {
      const probe = createSnapshotProbe('throwTimeout')
      addProbe(probe)

      const probes = getProbes('TestClass;throwTimeout')!

      // Let onEntry succeed with real time
      onEntry(probes, {}, { x: 1 })

      // Now make performance.now jump forward so the throw capture times out
      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (callCount <= 2) {
          return realNow()
        }
        return realNow() + 20
      })

      onThrow(probes, new Error('test'), {}, { x: 1 })

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should not affect non-snapshot probes', () => {
      const probe: Probe = {
        id: 'non-snapshot-timeout',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'nonSnapshot' },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      // Spike performance.now to simulate slow execution
      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (callCount <= 2) {
          return realNow()
        }
        return realNow() + 20
      })

      const probes = getProbes('TestClass;nonSnapshot')!
      onEntry(probes, {}, {})
      onReturn(probes, null, {}, {}, {})

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })

    it('should not leak active entries when entry capture times out', () => {
      const probe = createSnapshotProbe('entryLeakTest')
      addProbe(probe)

      let shouldTimeout = true
      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (!shouldTimeout || callCount <= 3) {
          return realNow()
        }
        return realNow() + 20
      })

      const probes = getProbes('TestClass;entryLeakTest')!
      // This onEntry will time out and push null
      onEntry(probes, {}, { x: 1 })

      // onReturn should handle the null entry gracefully (no snapshot sent)
      shouldTimeout = false
      callCount = 0
      onReturn(probes, null, {}, { x: 1 }, {})

      expect(mockBatchAdd).not.toHaveBeenCalled()
    })

    it('should skip subsequent snapshot probes after timeout but still process non-snapshot probes', () => {
      const snapshotProbe1: Probe = {
        id: 'timeout-shared-1',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'sharedDeadline' },
        template: 'Snapshot probe',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 3 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      const nonSnapshotProbe: Probe = {
        id: 'timeout-shared-2',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'sharedDeadline' },
        template: 'Non-snapshot probe',
        captureSnapshot: false,
        capture: {},
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      const snapshotProbe2: Probe = {
        id: 'timeout-shared-3',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'sharedDeadline' },
        template: 'Second snapshot probe',
        captureSnapshot: true,
        capture: { maxReferenceDepth: 3 },
        sampling: { snapshotsPerSecond: 5000 },
        evaluateAt: 'ENTRY',
      }
      addProbe(snapshotProbe1)
      addProbe(nonSnapshotProbe)
      addProbe(snapshotProbe2)

      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (callCount <= 3) {
          return realNow()
        }
        return realNow() + 20
      })

      const probes = getProbes('TestClass;sharedDeadline')!
      onEntry(probes, {}, { x: 1 })
      onReturn(probes, null, {}, { x: 1 }, {})

      // The non-snapshot probe should still send, but both snapshot probes should be dropped
      const calls = mockBatchAdd.calls.allArgs()
      expect(calls.length).toBe(1)
      expect(calls[0][0].message).toBe('Non-snapshot probe')
    })

    it('should share deadline across probes so second snapshot probe exits immediately', () => {
      const probe1 = createSnapshotProbe('sharedDeadline1')
      const probe2: Probe = {
        ...createSnapshotProbe('sharedDeadline2'),
        id: 'timeout-probe-sharedDeadline2',
        where: { typeName: 'TestClass', methodName: 'sharedDeadline1' },
      }
      addProbe(probe1)
      addProbe(probe2)

      let callCount = 0
      const realNow = performance.now.bind(performance)
      spyOn(performance, 'now').and.callFake(() => {
        callCount++
        if (callCount <= 3) {
          return realNow()
        }
        return realNow() + 20
      })

      const probes = getProbes('TestClass;sharedDeadline1')!
      onEntry(probes, {}, { x: 1 })
      onReturn(probes, null, {}, { x: 1 }, {})

      // Both snapshot probes share the deadline -- neither should send
      expect(mockBatchAdd).not.toHaveBeenCalled()
    })
  })

  describe('error handling', () => {
    it('should handle missing DD_RUM gracefully', () => {
      delete (window as any).DD_RUM

      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'errorHandling' },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;errorHandling')!
      expect(() => {
        onEntry(probes, {}, {})
        onReturn(probes, null, {}, {}, {})
      }).not.toThrow()

      expect(mockBatchAdd).toHaveBeenCalledTimes(1)
    })

    it('should handle uninitialized debugger transport gracefully', () => {
      resetDebuggerTransport()

      const probe: Probe = {
        id: 'test-probe',
        version: 0,
        type: 'LOG_PROBE',
        where: { typeName: 'TestClass', methodName: 'errorHandling' },
        template: 'Test',
        captureSnapshot: false,
        capture: {},
        sampling: {},
        evaluateAt: 'ENTRY',
      }
      addProbe(probe)

      const probes = getProbes('TestClass;errorHandling')!
      expect(() => {
        onEntry(probes, {}, {})
        onReturn(probes, null, {}, {}, {})
      }).not.toThrow()
      expect(warnSpy).toHaveBeenCalledWith(
        'Debugger transport is not initialized. Make sure DD_DEBUGGER.init() has been called.'
      )
    })
  })
})