@depup/sentry__node 10.44.0-depup.0

package/build/types-ts3.8/integrations/tracing/vercelai/instrumentation.d.ts

@@ -0,0 +1,56 @@
+import { InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+interface RecordingOptions {
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+}
+/**
+ * Process tool call results: capture tool errors and clean up span context mappings.
+ *
+ * Error checking runs first (needs span context for linking), then cleanup removes all entries.
+ * Tool errors are not rejected in Vercel AI V5 — they appear as metadata in the result content.
+ */
+export declare function processToolCallResults(result: unknown): void;
+/**
+ * Remove span context entries for all completed tool calls in the content array.
+ */
+export declare function cleanupToolCallSpanContexts(content: Array<object>): void;
+/**
+ * Determines whether to record inputs and outputs for Vercel AI telemetry based on the configuration hierarchy.
+ *
+ * The order of precedence is:
+ * 1. The vercel ai integration options
+ * 2. The experimental_telemetry options in the vercel ai method calls
+ * 3. When telemetry is explicitly enabled (isEnabled: true), default to recording
+ * 4. Otherwise, use the sendDefaultPii option from client options
+ */
+export declare function determineRecordingSettings(integrationRecordingOptions: RecordingOptions | undefined, methodTelemetryOptions: RecordingOptions, telemetryExplicitlyEnabled: boolean | undefined, defaultRecordingEnabled: boolean): {
+    recordInputs: boolean;
+    recordOutputs: boolean;
+};
+/**
+ * This detects is added by the Sentry Vercel AI Integration to detect if the integration should
+ * be enabled.
+ *
+ * It also patches the `ai` module to enable Vercel AI telemetry automatically for all methods.
+ */
+export declare class SentryVercelAiInstrumentation extends InstrumentationBase {
+    private _isPatched;
+    private _callbacks;
+    constructor(config?: InstrumentationConfig);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     */
+    init(): InstrumentationModuleDefinition;
+    /**
+     * Call the provided callback when the module is patched.
+     * If it has already been patched, the callback will be called immediately.
+     */
+    callWhenPatched(callback: () => void): void;
+    /**
+     * Patches module exports to enable Vercel AI telemetry.
+     */
+    private _patch;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/vercelai/types.d.ts

@@ -0,0 +1,59 @@
+import { Integration } from '@sentry/core';
+/**
+ * Telemetry configuration.
+ */
+export type TelemetrySettings = {
+    /**
+     * Enable or disable telemetry. Disabled by default while experimental.
+     */
+    isEnabled?: boolean;
+    /**
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
+    /**
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, AttributeValue>;
+};
+/**
+ * Attribute values may be any non-nullish primitive value except an object.
+ *
+ * null or undefined attribute values are invalid and will result in undefined behavior.
+ */
+export declare type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+export interface VercelAiOptions {
+    /**
+     * Enable or disable input recording. Enabled if `sendDefaultPii` is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled if `sendDefaultPii` is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     */
+    recordOutputs?: boolean;
+    /**
+     * By default, the instrumentation will register span processors only when the ai package is used.
+     * If you want to register the span processors even when the ai package usage cannot be detected, you can set `force` to `true`.
+     */
+    force?: boolean;
+}
+export interface VercelAiIntegration extends Integration {
+    options: VercelAiOptions;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/preload.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preload.d.ts.map

package/build/types-ts3.8/sdk/index.d.ts

@@ -0,0 +1,18 @@
+import { Integration, Options } from '@sentry/core';
+import { NodeClient } from '@sentry/node-core';
+import { NodeOptions } from '../types';
+/**
+ * Get default integrations, excluding performance.
+ */
+export declare function getDefaultIntegrationsWithoutPerformance(): Integration[];
+/** Get the default integrations for the Node SDK. */
+export declare function getDefaultIntegrations(options: Options): Integration[];
+/**
+ * Initialize Sentry for Node.
+ */
+export declare function init(options?: NodeOptions | undefined): NodeClient | undefined;
+/**
+ * Initialize Sentry for Node, without any integrations added by default.
+ */
+export declare function initWithoutDefaultIntegrations(options?: NodeOptions | undefined): NodeClient | undefined;
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/sdk/initOtel.d.ts

@@ -0,0 +1,31 @@
+import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { NodeClient } from '@sentry/node-core';
+import { AsyncLocalStorageLookup } from '@sentry/opentelemetry';
+interface AdditionalOpenTelemetryOptions {
+    /** Additional SpanProcessor instances that should be used. */
+    spanProcessors?: SpanProcessor[];
+}
+/**
+ * Initialize OpenTelemetry for Node.
+ */
+export declare function initOpenTelemetry(client: NodeClient, options?: AdditionalOpenTelemetryOptions): void;
+interface NodePreloadOptions {
+    debug?: boolean;
+    integrations?: string[];
+}
+/**
+ * Preload OpenTelemetry for Node.
+ * This can be used to preload instrumentation early, but set up Sentry later.
+ * By preloading the OTEL instrumentation wrapping still happens early enough that everything works.
+ */
+export declare function preloadOpenTelemetry(options?: NodePreloadOptions): void;
+/** Just exported for tests. */
+export declare function setupOtel(client: NodeClient, options?: AdditionalOpenTelemetryOptions): [
+    BasicTracerProvider,
+    AsyncLocalStorageLookup
+];
+/** Just exported for tests. */
+export declare function _clampSpanProcessorTimeout(maxSpanWaitDuration: number | undefined): number | undefined;
+export {};
+//# sourceMappingURL=initOtel.d.ts.map

package/build/types-ts3.8/types.d.ts

@@ -0,0 +1,89 @@
+import { Span as WriteableSpan } from '@opentelemetry/api';
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { ClientOptions, Options, SamplingContext, Scope, Span } from '@sentry/core';
+import { NodeTransportOptions, OpenTelemetryServerRuntimeOptions } from '@sentry/node-core';
+/**
+ * Base options for the Sentry Node SDK.
+ * Extends the common WinterTC options with OpenTelemetry support shared with Bun and other server-side SDKs.
+ */
+export interface BaseNodeOptions extends OpenTelemetryServerRuntimeOptions {
+    /**
+     * Sets profiling sample rate when @sentry/profiling-node is installed
+     *
+     * @deprecated
+     */
+    profilesSampleRate?: number;
+    /**
+     * Function to compute profiling sample rate dynamically and filter unwanted profiles.
+     *
+     * Profiling is enabled if either this or `profilesSampleRate` is defined. If both are defined, `profilesSampleRate` is
+     * ignored.
+     *
+     * Will automatically be passed a context object of default and optional custom data.
+     *
+     * @returns A sample rate between 0 and 1 (0 drops the profile, 1 guarantees it will be sent). Returning `true` is
+     * equivalent to returning 1 and returning `false` is equivalent to returning 0.
+     *
+     * @deprecated
+     */
+    profilesSampler?: (samplingContext: SamplingContext) => number | boolean;
+    /**
+     * Sets profiling session sample rate for the entire profiling session (evaluated once per SDK initialization).
+     *
+     * @default 0
+     */
+    profileSessionSampleRate?: number;
+    /**
+     * Set the lifecycle mode of the profiler.
+     * - **manual**: The profiler will be manually started and stopped via `startProfiler`/`stopProfiler`.
+     *    If a session is sampled, is dependent on the `profileSessionSampleRate`.
+     * - **trace**: The profiler will be automatically started when a root span exists and stopped when there are no
+     *    more sampled root spans. Whether a session is sampled, is dependent on the `profileSessionSampleRate` and the
+     *    existing sampling configuration for tracing (`tracesSampleRate`/`tracesSampler`).
+     *
+     * @default 'manual'
+     */
+    profileLifecycle?: 'manual' | 'trace';
+    /**
+     * Include local variables with stack traces.
+     *
+     * Requires the `LocalVariables` integration.
+     */
+    includeLocalVariables?: boolean;
+    /**
+     * Whether to register ESM loader hooks to automatically instrument libraries.
+     * This is necessary to auto instrument libraries that are loaded via ESM imports, but it can cause issues
+     * with certain libraries. If you run into problems running your app with this enabled,
+     * please raise an issue in https://github.com/getsentry/sentry-javascript.
+     *
+     * Defaults to `true`.
+     */
+    registerEsmLoaderHooks?: boolean;
+}
+/**
+ * Configuration options for the Sentry Node SDK
+ * @see @sentry/core Options for more information.
+ */
+export interface NodeOptions extends Options<NodeTransportOptions>, BaseNodeOptions {
+}
+/**
+ * Configuration options for the Sentry Node SDK Client class
+ * @see NodeClient for more information.
+ */
+export interface NodeClientOptions extends ClientOptions<NodeTransportOptions>, BaseNodeOptions {
+}
+export interface CurrentScopes {
+    scope: Scope;
+    isolationScope: Scope;
+}
+/**
+ * The base `Span` type is basically a `WriteableSpan`.
+ * There are places where we basically want to allow passing _any_ span,
+ * so in these cases we type this as `AbstractSpan` which could be either a regular `Span` or a `ReadableSpan`.
+ * You'll have to make sur to check relevant fields before accessing them.
+ *
+ * Note that technically, the `Span` exported from `@opentelemetry/sdk-trace-base` matches this,
+ * but we cannot be 100% sure that we are actually getting such a span, so this type is more defensive.
+ */
+export type AbstractSpan = WriteableSpan | ReadableSpan | Span;
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/utils/redisCache.d.ts

@@ -0,0 +1,16 @@
+import { CommandArgs as IORedisCommandArgs } from '@opentelemetry/instrumentation-ioredis';
+export declare const GET_COMMANDS: string[];
+export declare const SET_COMMANDS: string[];
+/** Checks if a given command is in the list of redis commands.
+ *  Useful because commands can come in lowercase or uppercase (depending on the library). */
+export declare function isInCommands(redisCommands: string[], command: string): boolean;
+/** Determine cache operation based on redis statement */
+export declare function getCacheOperation(command: string): 'cache.get' | 'cache.put' | 'cache.remove' | 'cache.flush' | undefined;
+/** Safely converts a redis key to a string (comma-separated if there are multiple keys) */
+export declare function getCacheKeySafely(redisCommand: string, cmdArgs: IORedisCommandArgs): string[] | undefined;
+/** Determines whether a redis operation should be considered as "cache operation" by checking if a key is prefixed.
+ *  We only support certain commands (such as 'set', 'get', 'mget'). */
+export declare function shouldConsiderForCache(redisCommand: string, keys: string[], prefixes: string[]): boolean;
+/** Calculates size based on the cache response value */
+export declare function calculateCacheItemSize(response: unknown): number | undefined;
+//# sourceMappingURL=redisCache.d.ts.map

package/changes.json

@@ -0,0 +1,10 @@
+{
+  "bumped": {
+    "@prisma/instrumentation": {
+      "from": "7.4.2",
+      "to": "^7.5.0"
+    }
+  },
+  "timestamp": "2026-03-17T22:56:38.457Z",
+  "totalUpdated": 1
+}

package/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "@depup/sentry__node",
+  "version": "10.44.0-depup.0",
+  "description": "[DepUp] Sentry Node SDK using OpenTelemetry for performance instrumentation",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/node",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "/build",
+    "changes.json",
+    "README.md"
+  ],
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./build/types/index.d.ts",
+        "default": "./build/esm/index.js"
+      },
+      "require": {
+        "types": "./build/types/index.d.ts",
+        "default": "./build/cjs/index.js"
+      }
+    },
+    "./import": {
+      "import": {
+        "default": "./build/import-hook.mjs"
+      }
+    },
+    "./loader": {
+      "import": {
+        "default": "./build/loader-hook.mjs"
+      }
+    },
+    "./init": {
+      "import": {
+        "default": "./build/esm/init.js"
+      },
+      "require": {
+        "default": "./build/cjs/init.js"
+      }
+    },
+    "./preload": {
+      "import": {
+        "default": "./build/esm/preload.js"
+      },
+      "require": {
+        "default": "./build/cjs/preload.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "<5.0": {
+      "build/types/index.d.ts": [
+        "build/types-ts3.8/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.6.0",
+    "@opentelemetry/core": "^2.6.0",
+    "@opentelemetry/instrumentation": "^0.213.0",
+    "@opentelemetry/instrumentation-amqplib": "0.60.0",
+    "@opentelemetry/instrumentation-connect": "0.56.0",
+    "@opentelemetry/instrumentation-dataloader": "0.30.0",
+    "@opentelemetry/instrumentation-express": "0.61.0",
+    "@opentelemetry/instrumentation-fs": "0.32.0",
+    "@opentelemetry/instrumentation-generic-pool": "0.56.0",
+    "@opentelemetry/instrumentation-graphql": "0.61.0",
+    "@opentelemetry/instrumentation-hapi": "0.59.0",
+    "@opentelemetry/instrumentation-http": "0.213.0",
+    "@opentelemetry/instrumentation-ioredis": "0.61.0",
+    "@opentelemetry/instrumentation-kafkajs": "0.22.0",
+    "@opentelemetry/instrumentation-knex": "0.57.0",
+    "@opentelemetry/instrumentation-koa": "0.61.0",
+    "@opentelemetry/instrumentation-lru-memoizer": "0.57.0",
+    "@opentelemetry/instrumentation-mongodb": "0.66.0",
+    "@opentelemetry/instrumentation-mongoose": "0.59.0",
+    "@opentelemetry/instrumentation-mysql": "0.59.0",
+    "@opentelemetry/instrumentation-mysql2": "0.59.0",
+    "@opentelemetry/instrumentation-pg": "0.65.0",
+    "@opentelemetry/instrumentation-redis": "0.61.0",
+    "@opentelemetry/instrumentation-tedious": "0.32.0",
+    "@opentelemetry/instrumentation-undici": "0.23.0",
+    "@opentelemetry/resources": "^2.6.0",
+    "@opentelemetry/sdk-trace-base": "^2.6.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@prisma/instrumentation": "^7.5.0",
+    "@fastify/otel": "0.17.1",
+    "@sentry/core": "10.44.0",
+    "@sentry/node-core": "10.44.0",
+    "@sentry/opentelemetry": "10.44.0",
+    "import-in-the-middle": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.1"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types",
+    "build:dev": "yarn build",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:types": "run-s build:types:core build:types:downlevel",
+    "build:types:core": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "yarn downlevel-dts build/types build/types-ts3.8 --to ts3.8",
+    "build:watch": "run-p build:transpile:watch",
+    "build:dev:watch": "yarn build:watch",
+    "build:transpile:watch": "rollup -c rollup.npm.config.mjs --watch",
+    "build:tarball": "npm pack",
+    "circularDepCheck": "madge --circular src/index.ts",
+    "clean": "rimraf build coverage sentry-node-*.tgz",
+    "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
+    "lint": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
+    "lint:es-compatibility": "es-check es2022 ./build/cjs/*.js && es-check es2022 ./build/esm/*.js --module",
+    "test": "yarn test:unit",
+    "test:unit": "vitest run",
+    "test:watch": "vitest --watch",
+    "yalc:publish": "yalc publish --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@sentry/node"
+  ],
+  "depup": {
+    "changes": {
+      "@prisma/instrumentation": {
+        "from": "7.4.2",
+        "to": "^7.5.0"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "@sentry/node",
+    "originalVersion": "10.44.0",
+    "processedAt": "2026-03-17T22:56:46.012Z",
+    "smokeTest": "passed"
+  }
+}