Packages

@sentry/node

11.9.0 · 23 Oct 2026MIT36.1M / weekRepositoryHomepagenpmAtom feed

Your version

578 stable releases, newest first, by release line. Notes are quoted as the maintainers published them.

  1. 10.x

  2. 10.43.0

    10 Mar 2026

    • nextjs: Add Turbopack support for React component name annotation

      We added experimental support for React component name annotation in Turbopack builds. When enabled, JSX elements are annotated with data-sentry-component, data-sentry-element, and data-sentry-source-file attributes at build time. This enables searching Replays by component name, seeing component names in breadcrumbs, and performance monitoring — previously only available with webpack builds.

      This feature requires Next.js 16+ and is currently behind an experimental flag:

      // next.config.ts
import { withSentryConfig } from '@sentry/nextjs';

export default withSentryConfig(nextConfig, {
  _experimental: {
    turbopackReactComponentAnnotation: {
      enabled: true,
      ignoredComponents: ['Header', 'Footer'], // optional
    },
  },
});

    • hono: Instrument middlewares app.use()

      Hono middleware registered via app.use() is now automatically instrumented, creating spans for each middleware invocation.

    • node-core,node: Add tracePropagation option to http and fetch integrations

  3. 10.42.0

    3 Mar 2026

    • consola: Enhance Consola integration to extract first-param object as searchable attributes

    • astro: Do not inject withSentry into Cloudflare Pages

    • core: Do not remove promiseBuffer entirely

  4. 10.41.0

    2 Mar 2026

    • core,cloudflare,deno: Add instrumentPostgresJsSql instrumentation

      Added a new instrumentation helper for the postgres (postgres.js) library, designed for SDKs that are not based on OpenTelemetry (e.g. Cloudflare, Deno). This wraps a postgres.js sql tagged template instance so that all queries automatically create Sentry spans.

      import postgres from 'postgres';
import * as Sentry from '@sentry/cloudflare'; // or '@sentry/deno'

export default Sentry.withSentry(env => ({ dsn: '__DSN__' }), {
  async fetch(request, env, ctx) {
    const sql = Sentry.instrumentPostgresJsSql(postgres(env.DATABASE_URL));

    // All queries now create Sentry spans
    const users = await sql`SELECT * FROM users WHERE id = ${userId}`;
    return Response.json(users);
  },
});

      The instrumentation is available in @sentry/core, @sentry/cloudflare, and @sentry/deno.

    • nextjs: Add Turbopack support for thirdPartyErrorFilterIntegration

      We added experimental support for the thirdPartyErrorFilterIntegration with Turbopack builds.

      This feature requires Next.js 16+ and is currently behind an experimental flag:

      // next.config.ts
import { withSentryConfig } from '@sentry/nextjs';

export default withSentryConfig(nextConfig, {
  _experimental: {
    turbopackApplicationKey: 'my-app-key',
  },
});

      Then configure the integration in your client instrumentation file with a matching key:

      // instrumentation-client.ts
import * as Sentry from '@sentry/nextjs';

Sentry.init({
  integrations: [
    Sentry.thirdPartyErrorFilterIntegration({
      filterKeys: ['my-app-key'],
      behaviour: 'apply-tag-if-exclusively-contains-third-party-frames',
    }),
  ],
});

    • core,cloudflare: Add dispose to the client for proper cleanup

  5. 10.40.0

    24 Feb 2026
    • breaking

      tanstackstart-react: Export Vite plugin from @sentry/tanstackstart-react/vite subpath

      The sentryTanstackStart Vite plugin is now exported from a dedicated subpath. Update your import:

      - import { sentryTanstackStart } from '@sentry/tanstackstart-react';
+ import { sentryTanstackStart } from '@sentry/tanstackstart-react/vite';

    • tanstackstart-react: Add global sentry exception middlewares

      The sentryGlobalRequestMiddleware and sentryGlobalFunctionMiddleware global middlewares capture unhandled exceptions thrown in TanStack Start API routes and server functions. Add them as the first entries in the requestMiddleware and functionMiddleware arrays of createStart():

      import { createStart } from '@tanstack/react-start/server';
import { sentryGlobalRequestMiddleware, sentryGlobalFunctionMiddleware } from '@sentry/tanstackstart-react/server';

export default createStart({
  requestMiddleware: [sentryGlobalRequestMiddleware, myRequestMiddleware],
  functionMiddleware: [sentryGlobalFunctionMiddleware, myFunctionMiddleware],
});

    • node-core: Reduce bundle size by removing apm-js-collab and requiring pino >= 9.10

      In order to keep receiving pino logs, you need to update your pino version to >= 9.10, the reason for the support bump is to reduce the bundle size of the node-core SDK in frameworks that cannot tree-shake the apm-js-collab dependency.

  6. 10.39.0

    16 Feb 2026

    • tanstackstart-react: Auto-instrument server function middleware

      The sentryTanstackStart Vite plugin now automatically instruments middleware in createServerFn().middleware([...]) calls. This captures performance data without requiring manual wrapping with wrapMiddlewaresWithSentry().

    • nextjs: New experimental automatic vercel cron monitoring

      Setting _experimental.vercelCronMonitoring to true in your Sentry configuration will automatically create Sentry cron monitors for your Vercel Cron Jobs.

      Please note that this is an experimental unstable feature and subject to change.

      // next.config.ts
export default withSentryConfig(nextConfig, {
  _experimental: {
    vercelCronMonitoring: true,
  },
});

    • node-core: Add node-core/light

      This release adds a new light-weight @sentry/node-core/light export to @sentry/node-core. The export acts as a light-weight SDK that does not depend on OpenTelemetry and emits no spans.

      Use this SDK when:

      It supports error tracking and reporting, logs, metrics, automatic request isolation (requires Node.js 22+) and basic tracing via our Sentry.startSpan* APIs.

      Install the SDK by running

      npm install @sentry/node-core

      and add Sentry at the top of your application's entry file:

      import * as Sentry from '@sentry/node-core/light';

Sentry.init({
  dsn: '__DSN__',
});

  7. 10.38.0

    29 Jan 2026

    • tanstackstart-react: Auto-instrument request middleware

      The sentryTanstackStart Vite plugin now automatically instruments middleware arrays in createFileRoute(). This captures performance data without requiring manual wrapping with wrapMiddlewaresWithSentry().

    • Use v4.8.0 bundler plugins

    • browser: Add logs.metrics bundle

  8. 10.37.0

    27 Jan 2026

    • core: Introduces a new Sentry.setConversationId() API to track multi turn AI conversations across API calls.

      You can now set a conversation ID that will be automatically applied to spans within that scope. This allows you to link traces from the same conversation together.

      import * as Sentry from '@sentry/node';

// Set conversation ID for all subsequent spans
Sentry.setConversationId('conv_abc123');

// All AI spans will now include the gen_ai.conversation.id attribute
await openai.chat.completions.create({...});

      This is particularly useful for tracking multiple AI API calls that are part of the same conversation, allowing you to analyze entire conversation flows in Sentry. The conversation ID is stored on the isolation scope and automatically applied to spans via the new conversationIdIntegration.

    • tanstackstart-react: Auto-instrument global middleware in sentryTanstackStart Vite plugin

      The sentryTanstackStart Vite plugin now automatically instruments requestMiddleware and functionMiddleware arrays in createStart(). This captures performance data without requiring manual wrapping.

      Auto-instrumentation is enabled by default. To disable it:

      // vite.config.ts
sentryTanstackStart({
  authToken: process.env.SENTRY_AUTH_TOKEN,
  org: 'your-org',
  project: 'your-project',
  autoInstrumentMiddleware: false,
});

    • core: Simplify truncation logic to only keep the newest message

  9. 10.36.0

    21 Jan 2026

    • node: Add Prisma v7 support

    • opentelemetry: Support db.system.name attribute for database spans

    • core: Sanitize data URLs in http.client spans

  10. 10.35.0

    19 Jan 2026

    • tanstackstart-react: Add sentryTanstackStart vite plugin to manage automatic source map uploads

      You can now configure source maps upload for TanStack Start using the sentryTanstackStart Vite plugin:

      // vite.config.ts
import { defineConfig } from 'vite';
import { sentryTanstackStart } from '@sentry/tanstackstart-react';
import { tanstackStart } from '@tanstack/react-start/plugin/vite';

export default defineConfig({
  plugins: [
    sentryTanstackStart({
      authToken: process.env.SENTRY_AUTH_TOKEN,
      org: 'your-org',
      project: 'your-project',
    }),
    tanstackStart(),
  ],
});

    • browser: Add CDN bundle for tracing.replay.feedback.logs.metrics

    • browser: Add shim package for logs

  11. 10.34.0

    14 Jan 2026

    • core: Add option to enhance the fetch error message

      You can now enable enhanced fetch error messages by setting the enhancedFetchErrorMessage option. When enabled, the SDK will include additional context in fetch error messages to help with debugging.

    • nextjs: Add routeManifestInjection option to exclude routes from client bundle

      A new routeManifestInjection option allows you to exclude sensitive routes from being injected into the client bundle.

    • tanstackstart-react: Add wrapMiddlewaresWithSentry for manual middleware instrumentation

      You can now wrap your middlewares using wrapMiddlewaresWithSentry, allowing you to trace middleware execution in your TanStack Start application.

      import { createMiddleware } from '@tanstack/react-start';
import { wrapMiddlewaresWithSentry } from '@sentry/tanstackstart-react';

const loggingMiddleware = createMiddleware({ type: 'function' }).server(async ({ next }) => {
  console.log('Request started');
  return next();
});

export const [wrappedLoggingMiddleware] = wrapMiddlewaresWithSentry({ loggingMiddleware });

  12. 10.33.0

    12 Jan 2026

    • core: Apply scope attributes to metrics

      You can now set attributes on the SDK's scopes which will be applied to all metrics as long as the respective scopes are active. For the time being, only string, number and boolean attribute values are supported.

      Sentry.getGlobalScope().setAttributes({ is_admin: true, auth_provider: 'google' });

Sentry.withScope(scope => {
  scope.setAttribute('step', 'authentication');

  // scope attributes `is_admin`, `auth_provider` and `step` are added
  Sentry.metrics.count('clicks', 1, { attributes: { activeSince: 100 } });
  Sentry.metrics.gauge('timeSinceRefresh', 4, { unit: 'hour' });
});

// scope attributes `is_admin` and `auth_provider` are added
Sentry.metrics.count('response_time', 283.33, { unit: 'millisecond' });

    • tracing: Add Vercel AI SDK v6 support

      The Sentry SDK now supports the Vercel AI SDK v6. Tracing and error monitoring will work automatically with the new version.

    • wasm: Add applicationKey option for third-party error filtering

      Adds support for applying an application key to WASM stack frames that can be then used in the thirdPartyErrorFilterIntegration for detection of first-party code.

      Usage:

      Sentry.init({
  integrations: [
    // Integration order matters: wasmIntegration needs to be before thirdPartyErrorFilterIntegration
    wasmIntegration({ applicationKey: 'your-custom-application-key' }), ←───┐
    thirdPartyErrorFilterIntegration({                                      │
      behaviour: 'drop-error-if-exclusively-contains-third-party-frames',   ├─ matching keys
      filterKeys: ['your-custom-application-key'] ←─────────────────────────┘
    }),
  ],
});

  13. 10.32.1

    19 Dec 2025

    Reading the note…

  14. 10.32.0

    18 Dec 2025

    • core: Apply scope attributes to logs

      You can now set attributes on the SDK's scopes which will be applied to all logs as long as the respective scopes are active. For the time being, only string, number and boolean attribute values are supported.

      Sentry.getGlobalScope().setAttributes({ is_admin: true, auth_provider: 'google' });

Sentry.withScope(scope => {
  scope.setAttribute('step', 'authentication');

  // scope attributes `is_admin`, `auth_provider` and `step` are added
  Sentry.logger.info(`user ${user.id} logged in`, { activeSince: 100 });
  Sentry.logger.info(`updated ${user.id} last activity`);
});

// scope attributes `is_admin` and `auth_provider` are added
Sentry.logger.warn('stale website version, reloading page');

    • replay: Add Request body with attachRawBodyFromRequest option

      To attach the raw request body (from Request objects passed as the first fetch argument) to replay events, you can now use the attachRawBodyFromRequest option in the Replay integration:

      Sentry.init({
  integrations: [
    Sentry.replayIntegration({
      attachRawBodyFromRequest: true,
    }),
  ],
});

    • tanstackstart-react: Trace server functions

      To enable tracing for server-side requests, you can now explicitly define a server entry point in your application and wrap your request handler with wrapFetchWithSentry.

      // src/server.ts
import { wrapFetchWithSentry } from '@sentry/tanstackstart-react';
import handler, { createServerEntry } from '@tanstack/react-start/server-entry';

export default createServerEntry(
  wrapFetchWithSentry({
    fetch(request: Request) {
      return handler.fetch(request);
    },
  }),
);

  15. 10.31.0

    16 Dec 2025

    • browser: Add support for GraphQL persisted operations

    • graphql.persisted_query.hash.sha256 - The SHA-256 hash of the persisted query

    • graphql.persisted_query.version - The version of the persisted query protocol

  16. 10.30.0

    11 Dec 2025
    • deprecated

      nextjs: Deprecate Webpack top-level options

    • node: Capture scope when event loop blocked

    • aws-serverless: Remove hyphens from AWS-lambda origins

  17. 10.29.0

    4 Dec 2025

    • solid|solidstart: Bump accepted @solidjs/router range

    • logs: Add support for msg in pino integration

    • node: Include system message in anthropic-ai messages span

  18. 10.28.0

    2 Dec 2025
    • breaking

      tanstackstart-react: Remove empty placeholder implementations

    • core: Make matcher parameter optional in makeMultiplexedTransport

    • nextjs: Support cacheComponents on turbopack

  19. 10.27.0

    24 Nov 2025
    • deprecated

      browserprofiling: Add manual mode and deprecate old profiling

      Adds the manual lifecycle mode for UI profiling (the default mode), allowing profiles to be captured manually with Sentry.uiProfiler.startProfiler() and Sentry.uiProfiler.stopProfiler(). The previous transaction-based profiling is with profilesSampleRate is now deprecated in favor of the new UI Profiling with profileSessionSampleRate.

    • core: Add gibibyte and pebibyte to InformationUnit type

    • core: Add scope attribute APIs

  20. 10.26.0

    19 Nov 2025
    • deprecated

      react-router: Deprecate ErrorBoundary exports

    • core: Instrument LangGraph Agent

    • cloudflare/vercel-edge: Add manual instrumentation for LangGraph

  21. 10.25.0

    11 Nov 2025

    • browser: Include Spotlight in development bundles

    • cloudflare: Add metrics exports

    • core: Truncate request string inputs in OpenAI integration

  22. 10.24.0

    10 Nov 2025
    • breaking

      metrics: Update types

    • metrics: Add top level option enableMetrics and beforeSendMetric

      This PR moves enableMetrics and beforeSendMetric out of the _experiments options. The metrics feature will now be enabled by default (none of our integrations will auto-emit metrics as of now), but you can disable sending metrics via enableMetrics: false. Metric options within _experiments got deprecated but will still work as of now, they will be removed with the next major version of our SDKs.

    • aws: Add SENTRY_LAYER_EXTENSION to configure using the lambda layer extension via env variables

  23. 10.23.0

    5 Nov 2025

    • core: Send user-agent header with envelope requests in server SDKs

    • browser: Limit transport buffer size

    • core: Remove default value of maxValueLength: 250

  24. 10.22.0

    24 Oct 2025

    • node: Instrument cloud functions for firebase v2

      We added instrumentation for Cloud Functions for Firebase v2, enabling automatic performance tracking and error monitoring. This will be added automatically if you have enabled tracing.

    • core: Instrument LangChain AI

      Instrumentation was added for LangChain AI operations. You can configure what is recorded like this:

      Sentry.init({
  integrations: [
    Sentry.langChainIntegration({
      recordInputs: true, // Record prompts/messages
      recordOutputs: true, // Record responses
    }),
  ],
});

    • cloudflare,vercel-edge: Add support for LangChain instrumentation

  25. 10.21.0

    21 Oct 2025

    • browserProfiling: Add trace lifecycle mode for UI profiling

      Adds a new trace lifecycle mode for UI profiling, allowing profiles to be captured for the duration of a trace. A manual mode will be added in a future release.

    • nuxt: Instrument Database

      Adds instrumentation for Nuxt database operations, enabling better performance tracking of database queries.

    • nuxt: Instrument server cache API

      Adds instrumentation for Nuxt's server cache API, providing visibility into cache operations.

  26. 10.20.0

    15 Oct 2025

    • flags: Add Growthbook integration

      Adds a new Growthbook integration for feature flag support.

    • solid: Add support for TanStack Router Solid

      Adds support for TanStack Router in the Solid SDK, enabling better routing instrumentation for Solid applications.

    • nextjs: Support native debugIds in turbopack

      Adds support for native Debug IDs in Turbopack, improving source map resolution and error tracking for Next.js applications using Turbopack. Native Debug ID generation will be enabled automatically for compatible versions.

  27. 10.19.0

    9 Oct 2025

    • tracemetrics: Add trace metrics behind an experiments flag

  28. 10.18.0

    7 Oct 2025

    • node: pino integration

      This release adds a new pino integration for Node.js, enabling Sentry to capture logs from the Pino logging library.

    • Remove @sentry/pino-transport package

      The @sentry/pino-transport package has been removed. Please use the new pino integration in @sentry/node instead.

    • node-core: Extend onnhandledrejection with ignore errors option

      Added support for selectively suppressing specific errors with configurable logging control in onnhandledrejection integration.

  29. 10.17.0

    30 Sep 2025

    • nuxt: Implement server middleware instrumentation

      This release introduces instrumentation for Nuxt middleware, ensuring that all middleware handlers are automatically wrapped with tracing and error reporting functionality.

    • fix(aws-serverless): Take http_proxy into account when choosing useLayerExtension default (#17817)

      The default setting for useLayerExtension now considers the http_proxy environment variable. When http_proxy is set, useLayerExtension will be off by default. If you use a http_proxy but would still like to make use of the Sentry Lambda extension, exempt localhost in a no_proxy environment variable.

    • node: Split up http integration into composable parts

  30. 10.16.0

    29 Sep 2025

    • logs: Add internal replay_is_buffering flag

    • react-router: Update loadContext type to be compatible with middleware

    • replay/logs: Only attach sampled replay Ids to logs

  31. 10.15.0

    24 Sep 2025

    • cloudflare: Add honoIntegration with error-filtering function

      This release adds a honoIntegration to @sentry/cloudflare, which exposes a shouldHandleError function that lets you define which errors in onError should be captured. By default, Sentry captures exceptions with error.status >= 500 || error.status <= 299.

      The integration is added by default, and it's possible to modify this behavior like this:

       integrations: [
   honoIntegration({
    shouldHandleError: (err) => true; // always capture exceptions in onError
   })
 ]

    • node: Add instrumentation for hono handler

    • aws: Enable Lambda extension by default when using the Lamba layer

  32. 10.14.0

    23 Sep 2025

    • cloudflare,vercel-edge: Add support for Google Gen AI instrumentation

      The SDK now supports manually instrumenting Google's Gen AI operations in Cloudflare Workers and Vercel Edge Runtime environments, providing insights into your AI operations. You can use const wrappedClient = Sentry.instrumentGoogleGenAIClient(genAiClient) to get an instrumented client.

    • nextjs: Display updated turbopack warnings

  33. 10.13.0

    22 Sep 2025

    • browser: Add option to explicitly end pageload span via reportPageLoaded()

      With this release you can take manual control of ending the pageload span. Usually this span is ended automatically by the SDK, based on a period of inactivity after the initial page was loaded in the browser. If you want full control over the pageload duration, you can tell Sentry, when your page was fully loaded:

      Sentry.init({
  //...
  integrations: [
    // 1. Enable manual pageload reporting
    Sentry.browserTracingIntegration({ enableReportPageLoaded: true }),
  ],
});

// 2. Whenever you decide the page is loaded, call:
Sentry.reportPageLoaded();

      Note that if Sentry.reportPageLoaded() is not called within 30 seconds of the initial pageload (or whatever value the finalTimeout option is set to), the pageload span will be ended automatically.

    • core,node: Add instrumentation for GoogleGenAI

      The SDK now automatically instruments the @google/genai package to provide insights into your AI operations.

    • nextjs: Promote useRunAfterProductionCompileHook to non-experimental build option

      The useRunAfterProductionCompileHook option is no longer experimental and is now a stable build option for Next.js projects.

  34. 10.12.0

    16 Sep 2025
    • removed

      node-core: Remove experimental note from winston api

    • feat(node) Ensure prismaIntegration works with Prisma 5

    • browser: Add timing and status atttributes to resource spans

  35. 10.11.0

    9 Sep 2025

    • aws: Add experimental AWS Lambda extension for tunnelling events

      This release adds an experimental Sentry Lambda extension to the existing Sentry Lambda layer. Sentry events are now tunneled through the extension and then forwarded to Sentry. This has the benefit of reducing the request processing time.

      To enable it, set _experiments.enableLambdaExtension in your Sentry config like this:

      Sentry.init({
  dsn: '<YOUR_DSN>',
  _experiments: {
    enableLambdaExtension: true,
  },
});

    • core: Add replay id to logs

    • core: Improve error handling for Anthropic AI instrumentation

  36. 10.10.0

    4 Sep 2025

    • browser: Add support for propagateTraceparent SDK option

    • core: Add tool calls attributes for Anthropic AI

    • nextjs: Use compiler hook for uploading turbopack sourcemaps

  37. 10.9.0

    3 Sep 2025

    • node: Update httpIntegration handling of incoming requests

    • browser: Add replay.feedback CDN bundle

    • browser: Export sendFeedback from CDN bundles

  38. 10.8.0

    29 Aug 2025

    • sveltekit: Add Compatibility for builtin SvelteKit Tracing

      This release makes the @sentry/sveltekit SDK compatible with SvelteKit's native observability support introduced in SvelteKit version 2.31.0. If you enable both, instrumentation and tracing, the SDK will now initialize early enough to set up additional instrumentation like database queries and it will pick up spans emitted from SvelteKit.

      We will follow up with docs how to set up the SDK soon. For now, If you're on SvelteKit version 2.31.0 or newer, you can easily opt into the new feature:

      If you prefer to stay on the hooks-file based config for now, the SDK will continue to work as previously.

    • react: Avoid multiple name updates on navigation spans

  39. 10.7.0

    27 Aug 2025

    • cloudflare: Add instrumentPrototypeMethods option to instrument RPC methods for DurableObjects

  40. 10.6.0

    26 Aug 2025

    • node: Add Anthropic AI integration

    • core: Instrument invoke_agent root span, and support Vercel ai v5

    • astro: Align options with shared build time options type

  41. 10.5.0

    12 Aug 2025

    • core: Better cause data extraction

    • node: Capture SystemError context and remove paths from message

    • nextjs: Inject Next.js version for dev symbolication

  42. 10.4.0

    11 Aug 2025

    • browser: Ensure IP address is only inferred by Relay if sendDefaultPii is true

    • node: Add ignoreStaticAssets

    • nuxt: Do not drop parametrized routes

  43. 10.3.0

    8 Aug 2025

    • core: MCP Server - Capture prompt results from prompt function calls

    • bun: Export skipOpenTelemetrySetup option

    • sveltekit: Streamline build logs

  44. 10.2.0

    6 Aug 2025

    • core: Add ignoreSpans option

    • cloudflare,vercel-edge: Add support for OpenAI instrumentation

    • astro: Streamline build logs

  45. 10.1.0

    4 Aug 2025

    • nuxt: Align build-time options to follow bundler plugins structure

    • browser-utils: Ensure web vital client hooks unsubscribe correctly

    • browser: Ensure request from diagnoseSdkConnectivity doesn't create span

  46. 10.0.0

    31 Jul 2025
    • breaking

      Bump to OpenTelemetry v2

    • breaking

      browser: Remove FID web vital collection

    • breaking

      core: Remove BaseClient

  47. 9.x

  48. 9.47.2

    29 Sep 2026

    Reading the note…

  49. 9.47.1

    17 Nov 2025

    Reading the note…

  50. 9.47.0

    17 Nov 2025

    Reading the note…

  51. 9.46.0

    13 Aug 2025

    Reading the note…

  52. 9.45.0

    8 Aug 2025

    Reading the note…