@depup/sentry__node 10.44.0-depup.0

package/build/types/types.d.ts

@@ -0,0 +1,89 @@
+import type { Span as WriteableSpan } from '@opentelemetry/api';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import type { ClientOptions, Options, SamplingContext, Scope, Span } from '@sentry/core';
+import type { 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/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,KAAK,EAAE,oBAAoB,EAAE,iCAAiC,EAAE,MAAM,mBAAmB,CAAC;AAEjG;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,iCAAiC;IACxE;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,CAAC,eAAe,EAAE,eAAe,KAAK,MAAM,GAAG,OAAO,CAAC;IAEzE;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEtC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAEtF;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,aAAa,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAElG,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,YAAY,GAAG,IAAI,CAAC"}

package/build/types/utils/redisCache.d.ts

@@ -0,0 +1,16 @@
+import type { 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/build/types/utils/redisCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisCache.d.ts","sourceRoot":"","sources":["../../../src/utils/redisCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAIhG,eAAO,MAAM,YAAY,UAAkB,CAAC;AAC5C,eAAO,MAAM,YAAY,UAAmB,CAAC;AAG7C;6FAC6F;AAC7F,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,GACd,WAAW,GAAG,WAAW,GAAG,cAAc,GAAG,aAAa,GAAG,SAAS,CAQxE;AAMD,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,EAAE,GAAG,SAAS,CA0BzG;AAED;uEACuE;AACvE,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAWxG;AAED,wDAAwD;AACxD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAmB5E"}

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

@@ -0,0 +1,7 @@
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export declare const DEBUG_BUILD: boolean;
+//# sourceMappingURL=debug-build.d.ts.map

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

@@ -0,0 +1,42 @@
+export { httpIntegration } from './integrations/http';
+export { nativeNodeFetchIntegration } from './integrations/node-fetch';
+export { fsIntegration } from './integrations/fs';
+export { expressIntegration, expressErrorHandler, setupExpressErrorHandler } from './integrations/tracing/express';
+export { fastifyIntegration, setupFastifyErrorHandler } from './integrations/tracing/fastify';
+export { graphqlIntegration } from './integrations/tracing/graphql';
+export { kafkaIntegration } from './integrations/tracing/kafka';
+export { lruMemoizerIntegration } from './integrations/tracing/lrumemoizer';
+export { mongoIntegration } from './integrations/tracing/mongo';
+export { mongooseIntegration } from './integrations/tracing/mongoose';
+export { mysqlIntegration } from './integrations/tracing/mysql';
+export { mysql2Integration } from './integrations/tracing/mysql2';
+export { redisIntegration } from './integrations/tracing/redis';
+export { postgresIntegration } from './integrations/tracing/postgres';
+export { postgresJsIntegration } from './integrations/tracing/postgresjs';
+export { prismaIntegration } from './integrations/tracing/prisma';
+export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/hapi';
+export { honoIntegration, setupHonoErrorHandler } from './integrations/tracing/hono';
+export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa';
+export { connectIntegration, setupConnectErrorHandler } from './integrations/tracing/connect';
+export { knexIntegration } from './integrations/tracing/knex';
+export { tediousIntegration } from './integrations/tracing/tedious';
+export { genericPoolIntegration } from './integrations/tracing/genericPool';
+export { dataloaderIntegration } from './integrations/tracing/dataloader';
+export { amqplibIntegration } from './integrations/tracing/amqplib';
+export { vercelAIIntegration } from './integrations/tracing/vercelai';
+export { openAIIntegration } from './integrations/tracing/openai';
+export { anthropicAIIntegration } from './integrations/tracing/anthropic-ai';
+export { googleGenAIIntegration } from './integrations/tracing/google-genai';
+export { langChainIntegration } from './integrations/tracing/langchain';
+export { langGraphIntegration } from './integrations/tracing/langgraph';
+export { launchDarklyIntegration, buildLaunchDarklyFlagUsedHandler, openFeatureIntegration, OpenFeatureIntegrationHook, statsigIntegration, unleashIntegration, growthbookIntegration, } from './integrations/featureFlagShims';
+export { firebaseIntegration } from './integrations/tracing/firebase';
+export { init, getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations, } from './sdk';
+export { initOpenTelemetry, preloadOpenTelemetry } from './sdk/initOtel';
+export { getAutoPerformanceIntegrations } from './integrations/tracing';
+export { NodeOptions } from './types';
+export { setOpenTelemetryContextAsyncContextStrategy as setNodeAsyncContextStrategy, } from '@sentry/opentelemetry';
+export { addBreadcrumb, isInitialized, isEnabled, getGlobalScope, lastEventId, close, createTransport, flush, SDK_VERSION, getSpanStatusFromHttpCode, setHttpStatus, captureCheckIn, withMonitor, requestDataIntegration, functionToStringIntegration, inboundFiltersIntegration, eventFiltersIntegration, linkedErrorsIntegration, addEventProcessor, setContext, setExtra, setExtras, setTag, setTags, setUser, setConversationId, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, setCurrentClient, Scope, setMeasurement, getSpanDescendants, parameterize, getClient, getCurrentScope, getIsolationScope, getTraceData, getTraceMetaTags, httpHeadersToSpanAttributes, winterCGHeadersToDict, continueTrace, withScope, withIsolationScope, captureException, captureEvent, captureMessage, captureFeedback, captureConsoleIntegration, dedupeIntegration, extraErrorDataIntegration, rewriteFramesIntegration, startSession, captureSession, endSession, addIntegration, startSpan, startSpanManual, startInactiveSpan, startNewTrace, suppressTracing, getActiveSpan, withActiveSpan, getRootSpan, spanToJSON, spanToTraceHeader, spanToBaggageHeader, trpcMiddleware, updateSpanName, supabaseIntegration, instrumentSupabaseClient, instrumentOpenAiClient, instrumentAnthropicAiClient, instrumentGoogleGenAIClient, zodErrorsIntegration, profiler, consoleLoggingIntegration, createConsolaReporter, consoleIntegration, wrapMcpServerWithSentry, featureFlagsIntegration, createLangChainCallbackHandler, instrumentLangGraph, instrumentStateGraphCompile, } from '@sentry/core';
+export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, RequestEventData, SdkInfo, Event, EventHint, ErrorEvent, Exception, Session, SeverityLevel, StackFrame, Stacktrace, Thread, User, Span, Metric, Log, LogSeverityLevel, FeatureFlagsIntegration, ExclusiveEventHintOrCaptureContext, CaptureContext, } from '@sentry/core';
+export { logger, metrics, httpServerIntegration, httpServerSpansIntegration, nodeContextIntegration, contextLinesIntegration, localVariablesIntegration, modulesIntegration, onUncaughtExceptionIntegration, onUnhandledRejectionIntegration, anrIntegration, disableAnrDetectionForCallback, spotlightIntegration, childProcessIntegration, processSessionIntegration, pinoIntegration, createSentryWinstonTransport, SentryContextManager, systemErrorIntegration, generateInstrumentOnce, getSentryRelease, defaultStackParser, createGetModuleFromFilename, makeNodeTransport, NodeClient, cron, NODE_VERSION, validateOpenTelemetrySetup, } from '@sentry/node-core';
+//# sourceMappingURL=index.d.ts.map

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

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

package/build/types-ts3.8/integrations/featureFlagShims/growthbook.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export the core GrowthBook integration for Node.js usage.
+ * The core integration is runtime-agnostic and works in both browser and Node environments.
+ */
+export declare const growthbookIntegrationShim: import("@sentry/core").IntegrationFn;
+//# sourceMappingURL=growthbook.d.ts.map

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

@@ -0,0 +1,6 @@
+export { launchDarklyIntegrationShim as launchDarklyIntegration, buildLaunchDarklyFlagUsedHandlerShim as buildLaunchDarklyFlagUsedHandler, } from './launchDarkly';
+export { openFeatureIntegrationShim as openFeatureIntegration, OpenFeatureIntegrationHookShim as OpenFeatureIntegrationHook, } from './openFeature';
+export { statsigIntegrationShim as statsigIntegration } from './statsig';
+export { unleashIntegrationShim as unleashIntegration } from './unleash';
+export { growthbookIntegrationShim as growthbookIntegration } from './growthbook';
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/featureFlagShims/launchDarkly.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a shim for the LaunchDarkly integration.
+ * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
+ */
+export declare const launchDarklyIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+/**
+ * This is a shim for the LaunchDarkly flag used handler.
+ */
+export declare function buildLaunchDarklyFlagUsedHandlerShim(): unknown;
+//# sourceMappingURL=launchDarkly.d.ts.map

package/build/types-ts3.8/integrations/featureFlagShims/openFeature.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This is a shim for the OpenFeature integration.
+ * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
+ */
+export declare const openFeatureIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+/**
+ * This is a shim for the OpenFeature integration hook.
+ */
+export declare class OpenFeatureIntegrationHookShim {
+    /**
+     *
+     */
+    constructor();
+    /**
+     *
+     */
+    after(): void;
+    /**
+     *
+     */
+    error(): void;
+}
+//# sourceMappingURL=openFeature.d.ts.map

package/build/types-ts3.8/integrations/featureFlagShims/statsig.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a shim for the Statsig integration.
+ * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
+ */
+export declare const statsigIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+//# sourceMappingURL=statsig.d.ts.map

package/build/types-ts3.8/integrations/featureFlagShims/unleash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is a shim for the Unleash integration.
+ * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
+ */
+export declare const unleashIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+//# sourceMappingURL=unleash.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * This integration will create spans for `fs` API operations, like reading and writing files.
+ *
+ * **WARNING:** This integration may add significant overhead to your application. Especially in scenarios with a lot of
+ * file I/O, like for example when running a framework dev server, including this integration can massively slow down
+ * your application.
+ *
+ * @param options Configuration for this integration.
+ */
+export declare const fsIntegration: (options?: {
+    /**
+     * Setting this option to `true` will include any filepath arguments from your `fs` API calls as span attributes.
+     *
+     * Defaults to `false`.
+     */
+    recordFilePaths?: boolean;
+    /**
+     * Setting this option to `true` will include the error messages of failed `fs` API calls as a span attribute.
+     *
+     * Defaults to `false`.
+     */
+    recordErrorMessagesAsSpanAttributes?: boolean;
+} | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1,139 @@
+import { ClientRequest, IncomingMessage, RequestOptions, ServerResponse } from 'node:http';
+import { HttpInstrumentationConfig } from '@opentelemetry/instrumentation-http';
+import { Span } from '@sentry/core';
+import { HTTPModuleRequestIncomingMessage, SentryHttpInstrumentationOptions } from '@sentry/node-core';
+import { NodeClientOptions } from '../types';
+interface HttpOptions {
+    /**
+     * Whether breadcrumbs should be recorded for outgoing requests.
+     * Defaults to true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * If set to false, do not emit any spans.
+     * This will ensure that the default HttpInstrumentation from OpenTelemetry is not setup,
+     * only the Sentry-specific instrumentation for request isolation is applied.
+     *
+     * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
+     */
+    spans?: boolean;
+    /**
+     * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.
+     * Read more about Release Health: https://docs.sentry.io/product/releases/health/
+     *
+     * Defaults to `true`.
+     */
+    trackIncomingRequestsAsSessions?: boolean;
+    /**
+     * Number of milliseconds until sessions tracked with `trackIncomingRequestsAsSessions` will be flushed as a session aggregate.
+     *
+     * Defaults to `60000` (60s).
+     */
+    sessionFlushingDelayMS?: number;
+    /**
+     * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing HTTP requests.
+     *
+     * When set to `false`, Sentry will not inject any trace propagation headers, but will still create breadcrumbs
+     * (if `breadcrumbs` is enabled). This is useful when `skipOpenTelemetrySetup: true` is configured and you want
+     * to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry's HttpInstrumentation.
+     *
+     * @default `true`
+     */
+    tracePropagation?: boolean;
+    /**
+     * Do not capture spans or breadcrumbs for outgoing HTTP requests to URLs where the given callback returns `true`.
+     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
+     *
+     * The `url` param contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.
+     * For example: `'https://someService.com/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type RequestOptions} object used to make the outgoing request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreOutgoingRequests?: (url: string, request: RequestOptions) => boolean;
+    /**
+     * Do not capture spans for incoming HTTP requests to URLs where the given callback returns `true`.
+     * Spans will be non recording if tracing is disabled.
+     *
+     * The `urlPath` param consists of the URL path and query string (if any) of the incoming request.
+     * For example: `'/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type IncomingMessage} object of the incoming request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreIncomingRequests?: (urlPath: string, request: IncomingMessage) => boolean;
+    /**
+     * A hook that can be used to mutate the span for incoming requests.
+     * This is triggered after the span is created, but before it is recorded.
+     */
+    incomingRequestSpanHook?: (span: Span, request: IncomingMessage, response: ServerResponse) => void;
+    /**
+     * Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc.
+     * This helps reduce noise in your transactions.
+     *
+     * @default `true`
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Do not capture spans for incoming HTTP requests with the given status codes.
+     * By default, spans with some 3xx and 4xx status codes are ignored (see @default).
+     * Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     */
+    dropSpansForIncomingRequestStatusCodes?: (number | [
+        number,
+        number
+    ])[];
+    /**
+     * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
+     * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
+     *
+     * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.
+     * @param request Contains the {@type RequestOptions} object used to make the incoming request.
+     */
+    ignoreIncomingRequestBody?: (url: string, request: RequestOptions) => boolean;
+    /**
+     * Controls the maximum size of incoming HTTP request bodies attached to events.
+     *
+     * Available options:
+     * - 'none': No request bodies will be attached
+     * - 'small': Request bodies up to 1,000 bytes will be attached
+     * - 'medium': Request bodies up to 10,000 bytes will be attached (default)
+     * - 'always': Request bodies will always be attached
+     *
+     * Note that even with 'always' setting, bodies exceeding 1MB will never be attached
+     * for performance and security reasons.
+     *
+     * @default 'medium'
+     */
+    maxIncomingRequestBodySize?: 'none' | 'small' | 'medium' | 'always';
+    /**
+     * If true, do not generate spans for incoming requests at all.
+     * This is used by Remix to avoid generating spans for incoming requests, as it generates its own spans.
+     */
+    disableIncomingRequestSpans?: boolean;
+    /**
+     * Additional instrumentation options that are passed to the underlying HttpInstrumentation.
+     */
+    instrumentation?: {
+        requestHook?: (span: Span, req: ClientRequest | HTTPModuleRequestIncomingMessage) => void;
+        responseHook?: (span: Span, response: HTTPModuleRequestIncomingMessage | ServerResponse) => void;
+        applyCustomAttributesOnSpan?: (span: Span, request: ClientRequest | HTTPModuleRequestIncomingMessage, response: HTTPModuleRequestIncomingMessage | ServerResponse) => void;
+    };
+}
+export declare const instrumentSentryHttp: ((options?: SentryHttpInstrumentationOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+export declare const instrumentOtelHttp: ((options?: HttpInstrumentationConfig | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/** Exported only for tests. */
+export declare function _shouldUseOtelHttpInstrumentation(options: HttpOptions, clientOptions?: Partial<NodeClientOptions>): boolean;
+/**
+ * The http integration instruments Node's internal http and https modules.
+ * It creates breadcrumbs and spans for outgoing HTTP requests which will be attached to the currently active span.
+ */
+export declare const httpIntegration: (options?: HttpOptions | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=http.d.ts.map

package/build/types-ts3.8/integrations/node-fetch.d.ts

@@ -0,0 +1,36 @@
+import { UndiciInstrumentationConfig } from '@opentelemetry/instrumentation-undici';
+interface NodeFetchOptions extends Pick<UndiciInstrumentationConfig, 'requestHook' | 'responseHook' | 'headersToSpanAttributes'> {
+    /**
+     * Whether breadcrumbs should be recorded for requests.
+     * Defaults to true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * If set to false, do not emit any spans.
+     * This will ensure that the default UndiciInstrumentation from OpenTelemetry is not setup,
+     * only the Sentry-specific instrumentation for breadcrumbs & trace propagation is applied.
+     *
+     * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
+     */
+    spans?: boolean;
+    /**
+     * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing fetch requests.
+     *
+     * When set to `false`, Sentry will not inject any trace propagation headers, but will still create breadcrumbs
+     * (if `breadcrumbs` is enabled). This is useful when `skipOpenTelemetrySetup: true` is configured and you want
+     * to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry's UndiciInstrumentation.
+     *
+     * @default `true`
+     */
+    tracePropagation?: boolean;
+    /**
+     * Do not capture spans or breadcrumbs for outgoing fetch requests to URLs where the given callback returns `true`.
+     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
+     */
+    ignoreOutgoingRequests?: (url: string) => boolean;
+}
+export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/core").Integration;
+/** Exported only for tests. */
+export declare function _getConfigWithDefaults(options?: Partial<NodeFetchOptions>): UndiciInstrumentationConfig;
+export {};
+//# sourceMappingURL=node-fetch.d.ts.map

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

@@ -0,0 +1,20 @@
+import { AmqplibInstrumentation } from '@opentelemetry/instrumentation-amqplib';
+export declare const instrumentAmqplib: ((options?: unknown) => AmqplibInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [amqplib](https://www.npmjs.com/package/amqplib) library.
+ *
+ * For more information, see the [`amqplibIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/amqplib/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.amqplibIntegration()],
+ * });
+ * ```
+ */
+export declare const amqplibIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=amqplib.d.ts.map

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

@@ -0,0 +1,59 @@
+import { AnthropicAiOptions } from '@sentry/core';
+export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the Anthropic AI SDK.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments Anthropic AI SDK client instances
+ * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.anthropicAIIntegration()],
+ * });
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
+ * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ *
+ * ### Default Behavior
+ *
+ * By default, the integration will:
+ * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
+ * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ *
+ * @example
+ * ```javascript
+ * // Record inputs and outputs when sendDefaultPii is false
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.anthropicAIIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.anthropicAIIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ */
+export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,19 @@
+import { InstrumentationBase, InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { AnthropicAiOptions } from '@sentry/core';
+type AnthropicAiInstrumentationOptions = InstrumentationConfig & AnthropicAiOptions;
+/**
+ * Sentry Anthropic AI instrumentation using OpenTelemetry.
+ */
+export declare class SentryAnthropicAiInstrumentation extends InstrumentationBase<AnthropicAiInstrumentationOptions> {
+    constructor(config?: AnthropicAiInstrumentationOptions);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     */
+    init(): InstrumentationModuleDefinition;
+    /**
+     * Core patch logic applying instrumentation to the Anthropic AI client constructor.
+     */
+    private _patch;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,46 @@
+import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';
+type ConnectApp = {
+    use: (middleware: any) => void;
+};
+export declare const instrumentConnect: ((options?: unknown) => ConnectInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).
+ *
+ * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.
+ *
+ * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.connectIntegration()],
+ * })
+ * ```
+ */
+export declare const connectIntegration: () => import("@sentry/core").Integration;
+/**
+ * Add a Connect middleware to capture errors to Sentry.
+ *
+ * @param app The Connect app to attach the error handler to
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const connect = require("connect");
+ *
+ * const app = connect();
+ *
+ * Sentry.setupConnectErrorHandler(app);
+ *
+ * // Add you connect routes here
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare const setupConnectErrorHandler: (app: ConnectApp) => void;
+export {};
+//# sourceMappingURL=connect.d.ts.map

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

@@ -0,0 +1,20 @@
+import { DataloaderInstrumentation } from '@opentelemetry/instrumentation-dataloader';
+export declare const instrumentDataloader: ((options?: unknown) => DataloaderInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.
+ *
+ * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.dataloaderIntegration()],
+ * });
+ * ```
+ */
+export declare const dataloaderIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=dataloader.d.ts.map