feat(node): pino integration

dev-packages/e2e-tests/test-applications/node-exports-test-app/scripts/consistentExports.ts

@@ -53,6 +53,7 @@ const DEPENDENTS: Dependent[] = [
       'NODE_VERSION',
       'childProcessIntegration',
       'systemErrorIntegration',
+      'pinoIntegration',
     ],
   },
   {

dev-packages/node-integration-tests/package.json

@@ -66,6 +66,8 @@
     "node-schedule": "^2.1.1",
     "openai": "5.18.1",
     "pg": "8.16.0",
+    "pino": "9.9.4",
+    "pino-next": "npm:pino@^9.12.0",
     "postgres": "^3.4.7",
     "prisma": "6.15.0",
     "proxy": "^2.1.1",

dev-packages/node-integration-tests/suites/pino/instrument.mjs

@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  release: '1.0',
+  enableLogs: true,
+  integrations: [Sentry.pinoIntegration({ error: { levels: ['error', 'fatal'] } })],
+});

dev-packages/node-integration-tests/suites/pino/scenario-next.mjs

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import pino from 'pino-next';
+
+const logger = pino({});
+
+Sentry.withIsolationScope(() => {
+  Sentry.startSpan({ name: 'startup' }, () => {
+    logger.info({ user: 'user-id', something: { more: 3, complex: 'nope' } }, 'hello world');
+  });
+});
+
+setTimeout(() => {
+  Sentry.withIsolationScope(() => {
+    Sentry.startSpan({ name: 'later' }, () => {
+      logger.error(new Error('oh no'));
+    });
+  });
+}, 1000);

dev-packages/node-integration-tests/suites/pino/scenario.mjs

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import pino from 'pino';
+
+const logger = pino({});
+
+Sentry.withIsolationScope(() => {
+  Sentry.startSpan({ name: 'startup' }, () => {
+    logger.info({ user: 'user-id', something: { more: 3, complex: 'nope' } }, 'hello world');
+  });
+});
+
+setTimeout(() => {
+  Sentry.withIsolationScope(() => {
+    Sentry.startSpan({ name: 'later' }, () => {
+      logger.error(new Error('oh no'));
+    });
+  });
+}, 1000);

dev-packages/node-integration-tests/suites/pino/test.ts

@@ -0,0 +1,172 @@
+import { join } from 'path';
+import { expect, test } from 'vitest';
+import { conditionalTest } from '../../utils';
+import { createRunner } from '../../utils/runner';
+
+conditionalTest({ min: 20 })('Pino integration', () => {
+  test('has different trace ids for logs from different spans', async () => {
+    const instrumentPath = join(__dirname, 'instrument.mjs');
+
+    await createRunner(__dirname, 'scenario.mjs')
+      .withMockSentryServer()
+      .withInstrument(instrumentPath)
+      .ignore('event')
+      .expect({
+        log: log => {
+          const traceId1 = log.items?.[0]?.trace_id;
+          const traceId2 = log.items?.[1]?.trace_id;
+          expect(traceId1).not.toBe(traceId2);
+        },
+      })
+      .start()
+      .completed();
+  });
+
+  test('captures event and logs', async () => {
+    const instrumentPath = join(__dirname, 'instrument.mjs');
+
+    await createRunner(__dirname, 'scenario.mjs')
+      .withMockSentryServer()
+      .withInstrument(instrumentPath)
+      .expect({
+        event: {
+          exception: {
+            values: [
+              {
+                type: 'Error',
+                value: 'oh no',
+                mechanism: {
+                  type: 'pino',
+                  handled: true,
+                },
+                stacktrace: {
+                  frames: expect.arrayContaining([
+                    expect.objectContaining({
+                      function: '?',
+                      in_app: true,
+                      module: 'scenario',
+                      context_line: "      logger.error(new Error('oh no'));",
+                    }),
+                  ]),
+                },
+              },
+            ],
+          },
+        },
+      })
+      .expect({
+        log: {
+          items: [
+            {
+              timestamp: expect.any(Number),
+              level: 'info',
+              body: 'hello world',
+              trace_id: expect.any(String),
+              severity_number: 9,
+              attributes: expect.objectContaining({
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.pino.level': { value: 30, type: 'integer' },
+                user: { value: 'user-id', type: 'string' },
+                something: {
+                  type: 'string',
+                  value: '{"more":3,"complex":"nope"}',
+                },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              }),
+            },
+            {
+              timestamp: expect.any(Number),
+              level: 'error',
+              body: 'oh no',
+              trace_id: expect.any(String),
+              severity_number: 17,
+              attributes: expect.objectContaining({
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.pino.level': { value: 50, type: 'integer' },
+                err: { value: '{}', type: 'string' },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              }),
+            },
+          ],
+        },
+      })
+      .start()
+      .completed();
+  });
+
+  test('captures with Pino integrated channel', async () => {
+    const instrumentPath = join(__dirname, 'instrument.mjs');
+
+    await createRunner(__dirname, 'scenario-next.mjs')
+      .withMockSentryServer()
+      .withInstrument(instrumentPath)
+      .expect({
+        event: {
+          exception: {
+            values: [
+              {
+                type: 'Error',
+                value: 'oh no',
+                mechanism: {
+                  type: 'pino',
+                  handled: true,
+                },
+                stacktrace: {
+                  frames: expect.arrayContaining([
+                    expect.objectContaining({
+                      function: '?',
+                      in_app: true,
+                      module: 'scenario-next',
+                      context_line: "      logger.error(new Error('oh no'));",
+                    }),
+                  ]),
+                },
+              },
+            ],
+          },
+        },
+      })
+      .expect({
+        log: {
+          items: [
+            {
+              timestamp: expect.any(Number),
+              level: 'info',
+              body: 'hello world',
+              trace_id: expect.any(String),
+              severity_number: 9,
+              attributes: expect.objectContaining({
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.pino.level': { value: 30, type: 'integer' },
+                user: { value: 'user-id', type: 'string' },
+                something: {
+                  type: 'string',
+                  value: '{"more":3,"complex":"nope"}',
+                },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              }),
+            },
+            {
+              timestamp: expect.any(Number),
+              level: 'error',
+              body: 'oh no',
+              trace_id: expect.any(String),
+              severity_number: 17,
+              attributes: expect.objectContaining({
+                'sentry.origin': { value: 'auto.logging.pino', type: 'string' },
+                'sentry.pino.level': { value: 50, type: 'integer' },
+                err: { value: '{}', type: 'string' },
+                'sentry.release': { value: '1.0', type: 'string' },
+                'sentry.sdk.name': { value: 'sentry.javascript.node', type: 'string' },
+              }),
+            },
+          ],
+        },
+      })
+      .start()
+      .completed();
+  });
+});

packages/astro/src/index.server.ts

@@ -94,6 +94,7 @@ export {
   onUnhandledRejectionIntegration,
   openAIIntegration,
   parameterize,
+  pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
   prismaIntegration,

packages/aws-serverless/src/index.ts

@@ -106,6 +106,7 @@ export {
   mysql2Integration,
   redisIntegration,
   tediousIntegration,
+  pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
   prismaIntegration,

packages/core/src/utils/worldwide.ts

@@ -48,6 +48,8 @@ export type InternalGlobal = {
    */
   _sentryModuleMetadata?: Record<string, any>;
   _sentryEsmLoaderHookRegistered?: boolean;
+  _sentryInjectLoaderHookRegister?: () => void;
+  _sentryInjectLoaderHookRegistered?: boolean;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */

packages/google-cloud-serverless/src/index.ts

@@ -106,6 +106,7 @@ export {
   mysql2Integration,
   redisIntegration,
   tediousIntegration,
+  pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
   prismaIntegration,

packages/node-core/package.json

@@ -68,9 +68,11 @@
   "dependencies": {
     "@sentry/core": "10.17.0",
     "@sentry/opentelemetry": "10.17.0",
+    "@apm-js-collab/tracing-hooks": "^0.3.1",
     "import-in-the-middle": "^1.14.2"
   },
   "devDependencies": {
+    "@apm-js-collab/code-transformer": "^0.8.2",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "^2.1.0",
     "@opentelemetry/core": "^2.1.0",

packages/node-core/src/index.ts

@@ -27,6 +27,7 @@ export { spotlightIntegration } from './integrations/spotlight';
 export { systemErrorIntegration } from './integrations/systemError';
 export { childProcessIntegration } from './integrations/childProcess';
 export { createSentryWinstonTransport } from './integrations/winston';
+export { pinoIntegration } from './integrations/pino';
 
 export { SentryContextManager } from './otel/contextManager';
 export { setupOpenTelemetryLogger } from './otel/logger';