fix(console): Re-patch console in AWS Lambda runtimes

packages/core/src/instrument/console.ts

@@ -32,8 +32,7 @@ function instrumentConsole(): void {
       originalConsoleMethods[level] = originalConsoleMethod;
 
       return function (...args: any[]): void {
-        const handlerData: HandlerDataConsole = { args, level };
-        triggerHandlers('console', handlerData);
+        triggerHandlers('console', { args, level } as HandlerDataConsole);
 
         const log = originalConsoleMethods[level];
         log?.apply(GLOBAL_OBJ.console, args);

packages/core/test/lib/instrument/console.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { addConsoleInstrumentationHandler } from '../../../src/instrument/console';
+import { GLOBAL_OBJ } from '../../../src/utils/worldwide';
+
+describe('addConsoleInstrumentationHandler', () => {
+  it.each(['log', 'warn', 'error', 'debug', 'info'] as const)(
+    'calls registered handler when console.%s is called',
+    level => {
+      const handler = vi.fn();
+      addConsoleInstrumentationHandler(handler);
+
+      GLOBAL_OBJ.console[level]('test message');
+
+      expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test message'], level }));
+    },
+  );
+
+  it('calls through to the underlying console method without throwing', () => {
+    addConsoleInstrumentationHandler(vi.fn());
+    expect(() => GLOBAL_OBJ.console.log('hello')).not.toThrow();
+  });
+});

packages/nextjs/src/index.types.ts

@@ -23,6 +23,7 @@ export declare function init(
 
 export declare const linkedErrorsIntegration: typeof clientSdk.linkedErrorsIntegration;
 export declare const contextLinesIntegration: typeof clientSdk.contextLinesIntegration;
+export declare const consoleIntegration: typeof serverSdk.consoleIntegration;
 export declare const spanStreamingIntegration: typeof clientSdk.spanStreamingIntegration;
 export declare const withStreamedSpan: typeof clientSdk.withStreamedSpan;
 

packages/node-core/src/common-exports.ts

@@ -27,6 +27,7 @@ export { systemErrorIntegration } from './integrations/systemError';
 export { childProcessIntegration } from './integrations/childProcess';
 export { createSentryWinstonTransport } from './integrations/winston';
 export { pinoIntegration } from './integrations/pino';
+export { consoleIntegration } from './integrations/console';
 
 // SDK utilities
 export { getSentryRelease, defaultStackParser } from './sdk/api';
@@ -117,7 +118,6 @@ export {
   profiler,
   consoleLoggingIntegration,
   createConsolaReporter,
-  consoleIntegration,
   wrapMcpServerWithSentry,
   featureFlagsIntegration,
   spanStreamingIntegration,

packages/node-core/src/integrations/console.ts

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { ConsoleLevel, HandlerDataConsole, WrappedFunction } from '@sentry/core';
+import {
+  CONSOLE_LEVELS,
+  GLOBAL_OBJ,
+  consoleIntegration as coreConsoleIntegration,
+  defineIntegration,
+  fill,
+  markFunctionWrapped,
+  maybeInstrument,
+  originalConsoleMethods,
+  triggerHandlers,
+} from '@sentry/core';
+
+interface ConsoleIntegrationOptions {
+  levels: ConsoleLevel[];
+}
+
+/**
+ * Node-specific console integration that captures breadcrumbs and handles
+ * the AWS Lambda runtime replacing console methods after our patch.
+ *
+ * In Lambda, console methods are patched via `Object.defineProperty` so that
+ * external replacements (by the Lambda runtime) are absorbed as the delegate
+ * while our wrapper stays in place. Outside Lambda, this delegates entirely
+ * to the core `consoleIntegration` which uses the simpler `fill`-based patch.
+ */
+export const consoleIntegration = defineIntegration((options: Partial<ConsoleIntegrationOptions> = {}) => {
+  return {
+    name: 'Console',
+    setup(client) {
+      if (process.env.LAMBDA_TASK_ROOT) {
+        maybeInstrument('console', instrumentConsoleLambda);
+      }
+
+      // Delegate breadcrumb handling to the core console integration.
+      const core = coreConsoleIntegration(options);
+      core.setup?.(client);
+    },
+  };
+});
+
+function instrumentConsoleLambda(): void {
+  const consoleObj = GLOBAL_OBJ?.console;
+  if (!consoleObj) {
+    return;
+  }
+
+  CONSOLE_LEVELS.forEach((level: ConsoleLevel) => {
+    if (level in consoleObj) {
+      patchWithDefineProperty(consoleObj, level);
+    }
+  });
+}
+
+function patchWithDefineProperty(consoleObj: Console, level: ConsoleLevel): void {
+  const nativeMethod = consoleObj[level] as (...args: unknown[]) => void;
+  originalConsoleMethods[level] = nativeMethod;
+
+  let delegate: Function = nativeMethod;
+  let savedDelegate: Function | undefined;
+  let isExecuting = false;
+
+  const wrapper = function (...args: any[]): void {
+    if (isExecuting) {
+      // Re-entrant call: a third party captured `wrapper` via the getter and calls it from inside their replacement. We must
+      // use `nativeMethod` (not `delegate`) to break the cycle, and we intentionally skip `triggerHandlers` to avoid duplicate
+      // breadcrumbs. The outer invocation already triggered the handlers for this console call.
+      nativeMethod.apply(consoleObj, args);
+      return;
+    }
+    isExecuting = true;
+    try {
+      triggerHandlers('console', { args, level } as HandlerDataConsole);
+      delegate.apply(consoleObj, args);
+    } finally {
+      isExecuting = false;
+    }
+  };
+  markFunctionWrapped(wrapper as unknown as WrappedFunction, nativeMethod as unknown as WrappedFunction);
+
+  // consoleSandbox reads originalConsoleMethods[level] to temporarily bypass instrumentation. We replace it with a distinct reference (.bind creates a
+  // new function identity) so the setter can tell apart "consoleSandbox bypass" from "external code restoring a native method captured before Sentry init."
+  const sandboxBypass = nativeMethod.bind(consoleObj);
+  originalConsoleMethods[level] = sandboxBypass;
+
+  try {
+    let current: any = wrapper;
+
+    Object.defineProperty(consoleObj, level, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return current;
+      },
+      set(newValue) {
+        if (newValue === wrapper) {
+          // consoleSandbox restoring the wrapper: recover the saved delegate.
+          if (savedDelegate !== undefined) {
+            delegate = savedDelegate;
+            savedDelegate = undefined;
+          }
+          current = wrapper;
+        } else if (newValue === sandboxBypass) {
+          // consoleSandbox entering bypass: save delegate, let getter return sandboxBypass directly so calls skip the wrapper entirely.
+          savedDelegate = delegate;
+          current = sandboxBypass;
+        } else if (typeof newValue === 'function' && !(newValue as WrappedFunction).__sentry_original__) {
+          delegate = newValue;
+          current = wrapper;
+        } else {
+          current = newValue;
+        }
+      },
+    });
+  } catch {
+    // Fall back to fill-based patching if defineProperty fails
+    fill(consoleObj, level, function (originalConsoleMethod: () => any): Function {
+      originalConsoleMethods[level] = originalConsoleMethod;
+
+      return function (this: Console, ...args: any[]): void {
+        triggerHandlers('console', { args, level } as HandlerDataConsole);
+        originalConsoleMethods[level]?.apply(this, args);
+      };
+    });
+  }
+}

packages/node-core/src/light/sdk.ts

@@ -1,7 +1,6 @@
 import type { Integration, Options } from '@sentry/core';
 import {
   applySdkMetadata,
-  consoleIntegration,
   consoleSandbox,
   debug,
   envToBool,
@@ -25,6 +24,7 @@ import { onUncaughtExceptionIntegration } from '../integrations/onuncaughtexcept
 import { onUnhandledRejectionIntegration } from '../integrations/onunhandledrejection';
 import { processSessionIntegration } from '../integrations/processSession';
 import { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from '../integrations/spotlight';
+import { consoleIntegration } from '../integrations/console';
 import { systemErrorIntegration } from '../integrations/systemError';
 import { defaultStackParser, getSentryRelease } from '../sdk/api';
 import { makeNodeTransport } from '../transports';

packages/node-core/src/sdk/index.ts

@@ -1,7 +1,6 @@
 import type { Integration, Options } from '@sentry/core';
 import {
   applySdkMetadata,
-  consoleIntegration,
   consoleSandbox,
   conversationIdIntegration,
   debug,
@@ -35,6 +34,7 @@ import { onUncaughtExceptionIntegration } from '../integrations/onuncaughtexcept
 import { onUnhandledRejectionIntegration } from '../integrations/onunhandledrejection';
 import { processSessionIntegration } from '../integrations/processSession';
 import { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration } from '../integrations/spotlight';
+import { consoleIntegration } from '../integrations/console';
 import { systemErrorIntegration } from '../integrations/systemError';
 import { makeNodeTransport } from '../transports';
 import type { NodeClientOptions, NodeOptions } from '../types';