@sentry/node 10.70.0 → 11.0.0-alpha.1

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

@@ -1,44 +0,0 @@
-import { SentryVercelAiInstrumentation } from './instrumentation';
-import { VercelAiOptions } from './types';
-export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.vercelAIIntegration()],
- * });
- * ```
- *
- * This integration adds tracing support to all `ai` function calls.
- * You need to opt-in to collecting spans for a specific call,
- * you can do so by setting `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: "VercelAI";
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,56 +0,0 @@
-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 dataCollection.genAI settings from client options
- */
-export declare function determineRecordingSettings(integrationRecordingOptions: RecordingOptions | undefined, methodTelemetryOptions: RecordingOptions, telemetryExplicitlyEnabled: boolean | undefined, defaultInputsEnabled: boolean, defaultOutputsEnabled: 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

@@ -1,50 +0,0 @@
-import { Integration } from '@sentry/core';
-import { VercelAiOptions as VercelAiBaseOptions } from '@sentry/server-utils';
-/**
- * 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 extends VercelAiBaseOptions {
-    /**
-     * 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

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

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

@@ -1,41 +0,0 @@
-import { Integration } from '@sentry/core';
-/**
- * The orchestrion-driven pieces, resolved lazily by the opt-in loader.
- *
- * IMPORTANT: this module (and everything `init()` imports) must NOT reference
- * the orchestrion code (`@sentry/server-utils/orchestrion/*`). The only
- * reference lives inside `experimentalUseDiagnosticsChannelInjection()` (a
- * separate module, reachable solely through that public export). That's the
- * tree-shaking boundary: if an app never calls the opt-in function, then a
- * bundler drops the entire orchestrion subtree, including its transitive
- * dependencies, while an app that does call it gets it bundled
- * normally.
- */
-export interface DiagnosticsChannelInjection {
-    /** Channel-based integrations to register, replacing their OTel equivalents. */
-    integrations: Integration[] | readonly Integration[];
-    /** OTel integration names these replace; filtered out of the default set. */
-    replacedOtelIntegrationNames: string[];
-    /** Installs the module hooks that inject the diagnostics channels. */
-    register: () => void;
-    /** Warns (DEBUG only) about missing or doubled channel injection. */
-    detect: () => void;
-}
-/**
- * Set by `experimentalUseDiagnosticsChannelInjection()`. The loader
- * is the only thing that pulls in the orchestrion modules; see
- * {@link DiagnosticsChannelInjection) re tree-shaking concerns this addresses.
- *
- * @internal
- */
-export declare function setDiagnosticsChannelInjectionLoader(load: () => DiagnosticsChannelInjection): void;
-/** Whether `experimentalUseDiagnosticsChannelInjection()` was called. */
-export declare function isDiagnosticsChannelInjectionEnabled(): boolean;
-/**
- * Resolve and memoize the orchestrion pieces. This is what actually loads
- * the orchestrion modules. Returns `undefined` if the app never opted in.
- * Callers gate this on span recording, so the modules load only when both
- * opted in and tracing is enabled.
- */
-export declare function resolveDiagnosticsChannelInjection(): DiagnosticsChannelInjection | undefined;
-//# sourceMappingURL=diagnosticsChannelInjection.d.ts.map

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

@@ -1,37 +0,0 @@
-import { channelIntegrations } from '@sentry/server-utils/orchestrion';
-import { RegisterDiagnosticsChannelInjectionOptions } from '@sentry/server-utils/orchestrion/register';
-export declare function diagnosticsChannelInjectionIntegrations(): typeof channelIntegrations;
-/**
- * EXPERIMENTAL: opt into diagnostics-channel-based auto-instrumentation.
- *
- * Call this BEFORE `Sentry.init()`:
- *
- * ```ts
- * import * as Sentry from '@sentry/node';
- *
- * Sentry.experimentalUseDiagnosticsChannelInjection();
- * Sentry.init({
- *   dsn: '__DSN__',
- *   // other settings...
- * });
- * ```
- *
- * When this has been called AND span recording is enabled, `Sentry.init()`
- * uses the diagnostics-channel-injection-based integrations instead of the
- * OpenTelemetry ones, and installs the module hooks that inject the channels
- * (so libraries imported after `init()` publish the channel events).
- *
- * This is a standalone function rather than an `init()` option so that a
- * bundler drops all of it (and its transitive deps) when this function isn't
- * called. `init()` reads the loader registered below.
- *
- * An app that DOES call it gets the orchestrion code bundled as intended.
- *
- * In an unbundled (server-side runtime) app this eagerly loads only the small
- * subscriber/channel modules; the heavy code-transform dependencies stay lazy
- * inside `register()` and load only when injection actually runs.
- *
- * @experimental May change or be removed in any release.
- */
-export declare function experimentalUseDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void;
-//# sourceMappingURL=experimentalUseDiagnosticsChannelInjection.d.ts.map

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

@@ -1,36 +0,0 @@
-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[];
-/**
- * When the app opted into diagnostics-channel injection (via
- * `experimentalUseDiagnosticsChannelInjection()`) AND span recording is enabled, drop the OTel
- * integrations that have a channel-based replacement and append the FULL channel-integration set,
- * so the two never both instrument the same library. Otherwise returns `integrations` unchanged.
- *
- * `_init` applies the same swap to `defaultIntegrations`, but SDKs that seed their integrations
- * through the user `integrations` option instead (e.g. the `@sentry/aws-serverless` Lambda layer
- * entry) never hit that path, so they call this directly from their own `getDefaultIntegrations`.
- *
- * Note the asymmetry: appended channel integrations are not limited to ones whose OTel counterpart
- * was in `integrations`. For `@sentry/node` that makes no difference (the incoming list carries the
- * whole OTel performance set), but a caller with a narrower list (e.g. `@sentry/aws-serverless`)
- * gains channel coverage for libraries it never shipped OTel integrations for. Channel integrations
- * produce nothing but spans, so this is gated on span recording. Exported so SDKs that build their
- * own default-integration set can apply the same logic instead of duplicating it.
- */
-export declare function applyDiagnosticsChannelInjectionIntegrations(integrations: Integration[], 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

@@ -1,30 +0,0 @@
-import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { NodeClient } from '@sentry/node-core';
-import { AsyncLocalStorageLookup, OpenTelemetryTracerProvider } 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): [
-    OpenTelemetryTracerProvider | undefined,
-    AsyncLocalStorageLookup | undefined
-];
-/** 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

@@ -1,89 +0,0 @@
-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

@@ -1,17 +0,0 @@
-export type IORedisCommandArgs = Array<string | Buffer | number | unknown[]>;
-export declare const GET_COMMANDS: string[];
-export declare const SET_COMMANDS: string[];
-export declare const REMOVE_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' | 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/build/types-ts3.8/utils/setHttpServerSpanRouteAttribute.d.ts

@@ -1,9 +0,0 @@
-/**
- * Set the `http.route` attribute on the root HTTP server span for the current trace.
- *
- * No-op when there is no active span, no root span, or the root span is not an
- * `http.server` span — so framework instrumentations can call this unconditionally
- * without risking attribute pollution on non-HTTP root spans.
- */
-export declare function setHttpServerSpanRouteAttribute(route: string): void;
-//# sourceMappingURL=setHttpServerSpanRouteAttribute.d.ts.map