feat(core): Move console integration into core and add to cloudflare/vercel-edge (#16024)

resolves #15439
resolves #4532

resolves https://linear.app/getsentry/issue/JSC-192

Supercedes #16021

Our console instrumentation was always inconsistent, but adding
breadcrumbs should not really be. This PR adds a unified console
instrumentation to `@sentry/core`, and makes the Node SDK use that. We
also add this to the `vercel-edge` and `cloudflare` SDKs.

I also left todo comments in the deno and browser SDKs for us to unify
into this single integration afterwards.

---------

Co-authored-by: Francesco Gringl-Novy <francesco.novy@sentry.io>

Author: AbhiPrasad

packages/browser/src/integrations/breadcrumbs.ts

@@ -74,6 +74,7 @@ const _breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) =>
   return {
     name: INTEGRATION_NAME,
     setup(client) {
+      // TODO(v10): Remove this functionality and use `consoleIntegration` from @sentry/core instead.
       if (_options.console) {
         addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));
       }

packages/cloudflare/src/index.ts

@@ -76,6 +76,7 @@ export {
   captureConsoleIntegration,
   moduleMetadataIntegration,
   zodErrorsIntegration,
+  consoleIntegration,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,

packages/cloudflare/src/sdk.ts

@@ -8,6 +8,7 @@ import {
   linkedErrorsIntegration,
   requestDataIntegration,
   stackParserFromStackParserOptions,
+  consoleIntegration,
 } from '@sentry/core';
 import type { CloudflareClientOptions, CloudflareOptions } from './client';
 import { CloudflareClient } from './client';
@@ -27,6 +28,7 @@ export function getDefaultIntegrations(options: CloudflareOptions): Integration[
     linkedErrorsIntegration(),
     fetchIntegration(),
     requestDataIntegration(sendDefaultPii ? undefined : { include: { cookies: false } }),
+    consoleIntegration(),
   ];
 }
 

packages/core/src/index.ts

@@ -108,6 +108,8 @@ export { extraErrorDataIntegration } from './integrations/extraerrordata';
 export { rewriteFramesIntegration } from './integrations/rewriteframes';
 export { zodErrorsIntegration } from './integrations/zoderrors';
 export { thirdPartyErrorFilterIntegration } from './integrations/third-party-errors-filter';
+export { consoleIntegration } from './integrations/console';
+
 export { profiler } from './profiling';
 export { instrumentFetchRequest } from './fetch';
 export { trpcMiddleware } from './trpc';

packages/core/src/integrations/console.ts

@@ -0,0 +1,95 @@
+import { addBreadcrumb } from '../breadcrumbs';
+import { getClient } from '../currentScopes';
+import { defineIntegration } from '../integration';
+import type { ConsoleLevel } from '../types-hoist';
+import {
+  CONSOLE_LEVELS,
+  GLOBAL_OBJ,
+  addConsoleInstrumentationHandler,
+  safeJoin,
+  severityLevelFromString,
+} from '../utils-hoist';
+
+interface ConsoleIntegrationOptions {
+  levels: ConsoleLevel[];
+}
+
+type GlobalObjectWithUtil = typeof GLOBAL_OBJ & {
+  util: {
+    format: (...args: unknown[]) => string;
+  };
+};
+
+const INTEGRATION_NAME = 'Console';
+
+/**
+ * Captures calls to the `console` API as breadcrumbs in Sentry.
+ *
+ * By default the integration instruments `console.debug`, `console.info`, `console.warn`, `console.error`,
+ * `console.log`, `console.trace`, and `console.assert`. You can use the `levels` option to customize which
+ * levels are captured.
+ *
+ * @example
+ *
+ * ```js
+ * Sentry.init({
+ *   integrations: [Sentry.consoleIntegration({ levels: ['error', 'warn'] })],
+ * });
+ * ```
+ */
+export const consoleIntegration = defineIntegration((options: Partial<ConsoleIntegrationOptions> = {}) => {
+  const levels = new Set(options.levels || CONSOLE_LEVELS);
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      addConsoleInstrumentationHandler(({ args, level }) => {
+        if (getClient() !== client || !levels.has(level)) {
+          return;
+        }
+
+        addConsoleBreadcrumb(level, args);
+      });
+    },
+  };
+});
+
+/**
+ * Capture a console breadcrumb.
+ *
+ * Exported just for tests.
+ */
+export function addConsoleBreadcrumb(level: ConsoleLevel, args: unknown[]): void {
+  const breadcrumb = {
+    category: 'console',
+    data: {
+      arguments: args,
+      logger: 'console',
+    },
+    level: severityLevelFromString(level),
+    message: formatConsoleArgs(args),
+  };
+
+  if (level === 'assert') {
+    if (args[0] === false) {
+      const assertionArgs = args.slice(1);
+      breadcrumb.message =
+        assertionArgs.length > 0 ? `Assertion failed: ${formatConsoleArgs(assertionArgs)}` : 'Assertion failed';
+      breadcrumb.data.arguments = assertionArgs;
+    } else {
+      // Don't capture a breadcrumb for passed assertions
+      return;
+    }
+  }
+
+  addBreadcrumb(breadcrumb, {
+    input: args,
+    level,
+  });
+}
+
+function formatConsoleArgs(values: unknown[]): string {
+  return 'util' in GLOBAL_OBJ && typeof (GLOBAL_OBJ as GlobalObjectWithUtil).util.format === 'function'
+    ? (GLOBAL_OBJ as GlobalObjectWithUtil).util.format(...values)
+    : safeJoin(values, ' ');
+}

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

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { addConsoleBreadcrumb } from '../../../src/integrations/console';
+import { addBreadcrumb } from '../../../src/breadcrumbs';
+
+vi.mock('../../../src/breadcrumbs', () => ({
+  addBreadcrumb: vi.fn(),
+}));
+
+describe('addConsoleBreadcrumb', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('creates a breadcrumb with correct properties for basic console log', () => {
+    const level = 'log';
+    const args = ['test message', 123];
+
+    addConsoleBreadcrumb(level, args);
+
+    expect(addBreadcrumb).toHaveBeenCalledWith(
+      expect.objectContaining({
+        category: 'console',
+        data: {
+          arguments: args,
+          logger: 'console',
+        },
+        level: 'log',
+        message: 'test message 123',
+      }),
+      {
+        input: args,
+        level,
+      },
+    );
+  });
+
+  it.each(['debug', 'info', 'warn', 'error'] as const)('handles %s level correctly', level => {
+    addConsoleBreadcrumb(level, ['test']);
+    expect(addBreadcrumb).toHaveBeenCalledWith(
+      expect.objectContaining({
+        level: expect.any(String),
+      }),
+      expect.any(Object),
+    );
+  });
+
+  it('skips breadcrumb for passed assertions', () => {
+    addConsoleBreadcrumb('assert', [true, 'should not be captured']);
+    expect(addBreadcrumb).not.toHaveBeenCalled();
+  });
+
+  it('creates breadcrumb for failed assertions', () => {
+    const args = [false, 'assertion failed', 'details'];
+
+    addConsoleBreadcrumb('assert', args);
+
+    expect(addBreadcrumb).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining('Assertion failed'),
+        data: {
+          arguments: args.slice(1),
+          logger: 'console',
+        },
+      }),
+      {
+        input: args,
+        level: 'assert',
+      },
+    );
+  });
+});

packages/deno/src/integrations/breadcrumbs.ts

@@ -42,6 +42,7 @@ const _breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) =>
   return {
     name: INTEGRATION_NAME,
     setup(client) {
+      // TODO(v10): Remove this functionality and use `consoleIntegration` from @sentry/core instead.
       if (_options.console) {
         addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));
       }

packages/node/src/index.ts

@@ -2,7 +2,6 @@ export { httpIntegration } from './integrations/http';
 export { nativeNodeFetchIntegration } from './integrations/node-fetch';
 export { fsIntegration } from './integrations/fs';
 
-export { consoleIntegration } from './integrations/console';
 export { nodeContextIntegration } from './integrations/context';
 export { contextLinesIntegration } from './integrations/contextlines';
 export { localVariablesIntegration } from './integrations/local-variables';
@@ -131,6 +130,7 @@ export {
   zodErrorsIntegration,
   profiler,
   consoleLoggingIntegration,
+  consoleIntegration,
 } from '@sentry/core';
 
 export type {

packages/node/src/integrations/console.ts

@@ -11,6 +11,7 @@ import {
   propagationContextFromHeaders,
   requestDataIntegration,
   stackParserFromStackParserOptions,
+  consoleIntegration,
 } from '@sentry/core';
 import {
   enhanceDscWithOpenTelemetryRootSpanName,
@@ -20,7 +21,6 @@ import {
 } from '@sentry/opentelemetry';
 import { DEBUG_BUILD } from '../debug-build';
 import { childProcessIntegration } from '../integrations/childProcess';
-import { consoleIntegration } from '../integrations/console';
 import { nodeContextIntegration } from '../integrations/context';
 import { contextLinesIntegration } from '../integrations/contextlines';
 import { httpIntegration } from '../integrations/http';

packages/node/src/sdk/index.ts

@@ -76,6 +76,7 @@ export {
   captureConsoleIntegration,
   moduleMetadataIntegration,
   zodErrorsIntegration,
+  consoleIntegration,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,

packages/node/test/integration/console.test.ts

@@ -22,6 +22,7 @@ import {
   nodeStackLineParser,
   requestDataIntegration,
   stackParserFromStackParserOptions,
+  consoleIntegration,
 } from '@sentry/core';
 import {
   SentryPropagator,
@@ -57,6 +58,7 @@ export function getDefaultIntegrations(options: Options): Integration[] {
     functionToStringIntegration(),
     linkedErrorsIntegration(),
     winterCGFetchIntegration(),
+    consoleIntegration(),
     ...(options.sendDefaultPii ? [requestDataIntegration()] : []),
   ];
 }