fix(v9/core): Fix logs flush timeout starvation with continuous logging

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });

packages/core/src/server-runtime-client.ts

@@ -36,6 +36,7 @@ export class ServerRuntimeClient<
 > extends Client<O> {
  private _logFlushIdleTimeout: ReturnType<typeof setTimeout> | undefined;
  private _logWeight: number;
+ private _isLogTimerActive: boolean;
 
  /**
  * Creates a new Edge SDK instance.
@@ -48,6 +49,7 @@ export class ServerRuntimeClient<
  super(options);
 
  this._logWeight = 0;
+ this._isLogTimerActive = false;
 
  // eslint-disable-next-line deprecation/deprecation
  const shouldEnableLogs = this._options.enableLogs ?? this._options._experiments?.enableLogs;
@@ -58,6 +60,7 @@ export class ServerRuntimeClient<
  client.on('flushLogs', () => {
  client._logWeight = 0;
  clearTimeout(client._logFlushIdleTimeout);
+ client._isLogTimerActive = false;
  });
 
  client.on('afterCaptureLog', log => {
@@ -68,10 +71,15 @@ export class ServerRuntimeClient<
  // the payload gets too big.
  if (client._logWeight >= 800_000) {
  _INTERNAL_flushLogsBuffer(client);
- } else {
- // start an idle timeout to flush the logs buffer if no logs are captured for a while
+ } else if (!client._isLogTimerActive) {
+ // Only start timer if one isn't already running.
+ // This prevents flushing being delayed by logs that arrive close to the timeout limit
+ // and thus resetting the flushing timeout and delaying logs being flushed.
+ client._isLogTimerActive = true;
  client._logFlushIdleTimeout = setTimeout(() => {
  _INTERNAL_flushLogsBuffer(client);
+ // Note: _isLogTimerActive is reset by the flushLogs handler above, not here,
+ // to avoid race conditions when new logs arrive during the flush.
  }, DEFAULT_LOG_FLUSH_INTERVAL);
  }
  });

packages/core/test/lib/server-runtime-client.test.ts

@@ -298,4 +298,155 @@ describe('ServerRuntimeClient', () => {
  expect(client['_logWeight']).toBe(0); // Weight should be reset after flush
  });
  });
+
+ describe('log timeout-based flushing', () => {
+ it('flushes logs after idle timeout', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).not.toHaveBeenCalled();
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('does not reset idle timeout when new logs are captured', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add initial log (starts the timer)
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward part of the idle timeout
+ vi.advanceTimersByTime(2500);
+
+ // Add another log which should NOT reset the timeout
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Fast forward the remaining time to reach the full timeout from the first log
+ vi.advanceTimersByTime(2500);
+
+ // Should have flushed both logs since timeout was not reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+
+ it('starts new timer after timeout completes and flushes', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // First batch: Add a log and let it flush
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+
+ // Fast forward to trigger the first flush
+ vi.advanceTimersByTime(5000);
+
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Second batch: Add another log after the first flush completed
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+
+ // Should not have flushed yet
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+
+ // Fast forward to trigger the second flush
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed the second log
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(2);
+
+ vi.useRealTimers();
+ });
+
+ it('does not start multiple timers for continuous logs', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add multiple logs in quick succession
+ _INTERNAL_captureLog({ message: 'test log 1', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 2', level: 'info' }, client);
+ _INTERNAL_captureLog({ message: 'test log 3', level: 'info' }, client);
+
+ // _isLogTimerActive should be true (only one timer running)
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Fast forward to trigger the timeout
+ vi.advanceTimersByTime(5000);
+
+ // Should have flushed all logs together
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_logWeight']).toBe(0);
+ expect(client['_isLogTimerActive']).toBe(false);
+
+ vi.useRealTimers();
+ });
+
+ it('clears timer and flag when weight threshold is exceeded', () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultClientOptions({
+ dsn: PUBLIC_DSN,
+ enableLogs: true,
+ });
+ client = new ServerRuntimeClient(options);
+
+ const sendEnvelopeSpy = vi.spyOn(client, 'sendEnvelope');
+
+ // Add a small log that starts the timer
+ _INTERNAL_captureLog({ message: 'small log', level: 'info' }, client);
+
+ expect(client['_isLogTimerActive']).toBe(true);
+
+ // Add a large log that exceeds the weight threshold
+ const largeMessage = 'x'.repeat(400_000); // 400KB string
+ _INTERNAL_captureLog({ message: largeMessage, level: 'info' }, client);
+
+ // Should have flushed due to weight, and timer flag should be reset
+ expect(sendEnvelopeSpy).toHaveBeenCalledTimes(1);
+ expect(client['_isLogTimerActive']).toBe(false);
+ expect(client['_logWeight']).toBe(0);
+
+ vi.useRealTimers();
+ });
+ });
 });